Discussion :

[Ja Rasta]

Bonjour à tous,
D'après ce que j'ai compris sur les thread,ce qu'ils permettent de faire le multitâche donc du coup pour moi pour q'un thread puisse fonctionner il doit en exister d'autres afin qu'il ait communication.Mais ce que je n'arrive pas à comprendre ce que ce code fonctionne pourtant il n'y a qu'un thread(listener) :

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
public static void main(String[] args) throws IOException, InterruptedException {

	private final BlockingQueue<ByteBuffer> queue = new ArrayBlockingQueue<ByteBuffer>(1);
	private DatagramChannel dc;

        dc=DatagramChannel.open();
        dc.bind(null);

        private final Thread listener = new Thread(() -> {
		ByteBuffer bufferReceive = ByteBuffer.allocate(BUFFER_SIZE);
		while (!Thread.interrupted()) {
			try {
				bufferReceive.clear();
				receive(bufferReceive);

                                 /*svp pourquoi si je fais 
                                  *bufferReceive.flip();
                                  *queue.put(bufferReceive);
                                  *ça ne marche pas?j'ai une erreur de type ByteBufferUnderFlowException.
                                  */
				queue.put(bufferReceive.duplicate());//et ici quelqu'un peut m'expliquer svp pourquoi ça marche avec duplicate()? et quel est l'intérêt?
                              

			} catch (IOException e) {
				e.printStackTrace();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	});
	listener.start();

      ByteBuffer bufferToSend = createPacket(requestNumber, s, cs);
      bufferToSend.flip();
      send(bufferToSend);

      ByteBuffer bufferResponse = ByteBuffer.allocate(BUFFER_SIZE);
      bufferResponse = queue.poll(TIMEOUT, TimeUnit.MILLISECONDS);
}

De plus j'aimerai savoir la différence entre les 2 méthodes ci-dessous de sleep d'un thread :

Code :

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

1
2
3
4
5
6
7
8
9
 
Thread ts = new Thread(new Runnable() {
			@Override
			public void run() {
				while (!Thread.interrupted()) {
				        Thread.sleep(TIMEOUT);
			}
		});
ts.sleep(TIMEOUT);

Merci d'avance!!!

[Gugelhupf]

Salut,

Je ne comprends pas ta première question, les bytebuffers et threads sont deux concepts différents. C'est comme essayer d'expliquer la différence entre un papillon et un immeuble.
Pour ce qui est de ta deuxième question il n'y a pas de différence car c'est la même méthode (lien Javadoc).

A+

[pk960]

Bonjour,
Pour la première question, il y a plus d'un thread dans l'extrait de code : il y a le thread listener, mais il y a aussi le thread exécutant la méthode main. Tout programme a au minimum 1 thread !
Pour la deuxième question, il faut noter que la méthode demande que le thread en cours d'exécution stoppe son exécution durant le temps passé en paramètre.
Si l'appel dans la boucle permet d'éviter que le thread ts fasse de l'attente active, l'autre appel est trompeur car il stoppe l'exécution, non pas du thread ts, mais du thread qui a créé le thread ts puisque c'est lui qui est en cours d'exécution.
D'ailleurs, le compilateur doit certainement produire un avertissement sur cette ligne car c'est une mauvaise pratique d'appeler une méthode statique via un objet.