Discussion :

[damien77]

Bonjour, je suis en train de faire un t'chat et j'aimerais avoir 2-3 conseils.
Donc j'ai 3 classes pour le moment.
- Server. ( comprend un thread pour savoir si un client ce connecte )
- Event. ( connexion des clients, envoyer des messages etc... )
- Client. ( un thread qui récupère les flux envoyer par le client )

Chaque évenement du serveur passe par la classe Event qui ressemble à ceci pour le moment :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
public class Event
{
   ConcurrentLinkedQueue<String> action ;
 
   public void addMessage(String m)
   {
      action.add(m);
   }
 
   /* et ensuite un Thread qui dépile les messages. Interprête ceci. et en      fonction du message. Agit sur la class Client ou Server, voir les deux à la fois. */
   .....
}

D'un point de vue technique. Mon code vous semble-il correct ou bien je risque d'avoir des problèmes de synchronisation ?

merci d'avance

[elmor]

Vue le code que je vois, non tu n'auras pas de problème de synchro.
Mais Franchement tu es trop vague pour que je puisse voir les problème de synchro.

Le seul problème est que je ne vois pas comment tu informes ton thread qu'il y a un nouveau message dans le queue .... ? Attention ton thread doit éviter de faire une attente active.

Si tu veux une liste offrant un reveil automatique de ton thread lorsqu'un message arrive dans la queue tu devrait utiliser la "LinkedBlockingQueue" et on thread serait en attente sur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
LinkedBlockingQueue queue;
...
queue.take()

[damien77]

Voilà le code très réduit qui montre une connexion et l'envois de message :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
 
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentLinkedQueue;
 
public class Main {
 
    public static void main(String[] args) {
        Server.getInstance() ;
    }
 
}
 
class Server implements Runnable
{
 
    private int port ;
 
    private Thread thread ;
 
    private List<Client> clients ;
 
    private ServerSocket socket ;
 
    private static Server instance ;
 
    public synchronized static Server getInstance()
    {
        if(instance==null)
        {
            instance = new Server();
        }
        return instance ;
    }
 
    private Server()
    {
        try {
            port = 13000;
            clients = new ArrayList<Client>();
            socket = new ServerSocket(port);
            thread = new Thread(this);
            thread.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public int getPort() {
        return port;
    }
 
    public void setPort(int port) {
        this.port = port;
    }
 
    public List<Client> getClients() {
        return clients;
    }
 
    @Override
    public void run() {
        while(true)
        {
            try {
                Socket client = socket.accept();
                MessageInOut.getInstance().addOut( new MessageOut("nouveau client",client) );
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
    public void addClient(Client client)
    {
        clients.add(client);
    }
 
}
 
class Client implements Runnable
{
 
    private String pseudo ;
 
    public static int ID = 0;
 
    private Thread thread ;
 
    private PrintWriter writer ;
 
    private Socket socket ;
 
    private InputStream input ;
 
    public Client(Socket socket)
    {
        pseudo = "UTILISATEUR_" + ID ;
        ID++;
        this.socket = socket ;
        try {
            writer = new PrintWriter(socket.getOutputStream());
            input = socket.getInputStream() ;
        } catch (IOException e) {
            e.printStackTrace();
        }
        thread = new Thread(this);
        thread.start();
    }
 
    public String getPseudo()
    {
        return pseudo ;
    }
 
    @Override
    public void run() 
    {
        while(true)
        {
            try {
                int entier = 0;
                String chaine = "" ;
                while( ( entier = input.read() ) != -1 )
                {
                    chaine += (char)entier ; 
                }
                chaine = pseudo + " : " + chaine ;
                MessageInOut.getInstance().addOut( new MessageOut("message",chaine) );
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
    public PrintWriter getWriter()
    {
        return writer ;
    }
 
}
 
class MessageInOut implements Runnable
{
 
    private ConcurrentLinkedQueue<MessageIn> ins ;
 
    private ConcurrentLinkedQueue<MessageOut> outs ;
 
    private Thread thread;
 
    private static MessageInOut instance ;
 
    public synchronized static MessageInOut getInstance()
    {
        if(instance==null)
        {
            instance = new MessageInOut();
        }
        return instance ;
    }    
 
    public MessageInOut()
    {
        ins = new ConcurrentLinkedQueue<MessageIn>();
        outs = new  ConcurrentLinkedQueue<MessageOut>();
        thread = new Thread(this);
        thread.start();
    }
 
    public void addOut(MessageOut outs)
    {
        this.outs.add(outs);
    }
 
    public void addIn(MessageIn ins)
    {
        this.ins.add(ins);
    }
 
    @Override
    public void run() {
        while(true)
        {
            messageOutParse( outs.peek() );
            messageInParse( ins.peek() );
        }
    }    
 
    public void messageOutParse(MessageOut out)
    {
        if(out==null)
        {
            if( out.getMessage().equals("nouveau client") )
            {
                Client client = new Client( (Socket)out.getO() );
                addIn( new MessageIn("Nouveau client : " + client.getPseudo() ,Server.getInstance().getClients()) );
                Server.getInstance().addClient(client);
                addIn( new MessageIn("Bonjour !!!!",client) );
            }
            else if( out.getMessage().equals("message")  )
            {
                addIn( new MessageIn( (String)out.getO() ,Server.getInstance().getClients()) );
            }
        }
    }
 
    public void messageInParse(MessageIn in)
    {
        if(in==null)
        {
            if( in.getO() instanceof Client )
            {
                Client c = (Client)in.getO();
                c.getWriter().write( in.getMessage() );
                c.getWriter().flush();
            }
            else
            {
                List<Client> c = (List<Client>)in.getO();
                for (Client client : c) {
                    client.getWriter().write( in.getMessage() );
                    client.getWriter().flush();
                }
            }
        }
    }    
 
}
 
class MessageIn
{
    private String message ;
 
    private Object o ;
 
    public MessageIn(String message, Object o) {
        super();
        this.message = message;
        this.o = o;
    }
 
    public String getMessage() {
        return message;
    }
 
    public void setMessage(String message) {
        this.message = message;
    }
 
    public Object getO() {
        return o;
    }
 
    public void setO(Object o) {
        this.o = o;
    }
 
}
 
class MessageOut
{
 
    private String message ;
 
    private Object o ;
 
    public MessageOut(String message, Object o) {
        super();
        this.message = message;
        this.o = o;
    }
 
    public String getMessage() {
        return message;
    }
 
    public void setMessage(String message) {
        this.message = message;
    }
 
    public Object getO() {
        return o;
    }
 
    public void setO(Object o) {
        this.o = o;
    }
 
}

[elmor]

Vu ton code tu n'as pas de probème de synchro mais ce qui te sauve est le fait que tous les messages soient traités par un seul et unique thread (goulot d'etranglement).

Mes remarques sont :
* Attention ton server fait une attente active

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
   while(true)
        {
            messageOutParse( outs.peek() );
            messageInParse( ins.peek() );
        }

le peek est non bloquant donc ton thread "MessageInOut" prend enormement de CPU meme lorsqu'il n'y a pas de messages

* Le thread "MessageInOut" traite toujours le meme message car outs.peek() te retourne la tete de la queue mais ne retire pas l'element...

* tes threads clients ne lisent pas les messages car ils lisent jusqu'a '-1'
hors -1 n'est retourne qu'a la fin du stream ...
* tu ne geres pas le fait qu'un client ce deconnecte


Donc actuellement le code actuel ne fonctionne pas mais le pb n'est pas la synchro.

[damien77]

J'ai simplifié le code. car j'ai la gestion de la console d'administration.
démarrage / arrêt du serveur
déconnexion des clients.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
    public void run() {
            try {
                while(true)
                {
                messageOutParse( outs.poll() );
                messageInParse( ins.poll() );
                Thread.sleep(60);
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    }