Délai d'exécution de thread

Version imprimable

Bonjour,
j'ai un problème à propos de mémoire partagée+thread, voilà le contexte:
depuis un client A j'envoie un message;
le client B reçoit le message
le client B envoie un ACK correspondant au message reçu;
le client A reçoit l'ACK correspondant au message qu'il vient d'envoyer et envoie un nouveau message.

Mon problème se situe lors de la réception de l'ACK par le client A (l'émetteur du message d'origine). En effet, je ne dois envoyer le prochain paquet qu'à 2 conditions:
_ l'ACK que je viens de recevoir correspond bien au message que je viens d'envoyer;
ET
_ j'ai reçu l'ACK du message avant 100ms (dépassé ce délai, le message d'origine est tout simplement renvoyé).
La première condition est triviale, mais la seconde l'est beaucoup moins.
J'ai testé 2 pistes qui me semblent les plus adéquates:
_ utiliser la classe Timer avec son schedule(TimerTask, long)
_ utiliser les threads (mais là j'avoue avoir quelques difficultés alors que je crois que ma solution en est étroitement liée)

Voici mon code pour l'instant (utilisant la notion de thread):

Code:

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
package communication.system;
 
//Add-ons packages
import communication.main.Message;
 
//Exceptions packages
import java.io.FileNotFoundException;
import java.io.IOException;
 
/**
 * This class will wait all acknowledgements of each packet sent
 * 
 * @version 8.0, 24/11/07
 * @since   version 1.0
 *
 */
public class WaitForAcknowledgement extends Thread {
	/**
         * This method will wait while an ACK isn't received
         * @return true if ID acknowledgement received is the same that ID packet sent 
         */
 
	private static Integer integer = -1;
	private static Message messageMessage;
 
	/**
         * Constructor
         * @param message
         */
	WaitForAcknowledgement (Message message) {
		messageMessage = message;
	}// WaitForAcknowledgement (Message)
 
	/**
         * Method who will wait each ACK
         * @param id the last packet Id
         * @param message This object Message is used only to get network parameter
         * @return a boolean: TRUE if Id ack packet and Id data packet is same, otherwise FALSE
         * @throws FileNotFoundException
         * @throws IOException
         * @throws InterruptedException
         */
	public static boolean waitForAck(int id, Message message)
	throws FileNotFoundException, IOException, InterruptedException {		
 
		//create my thread calling WaitForAcknowledgement class constructor
		Thread T = new WaitForAcknowledgement(message);
 
		//Waits at most 100 milliseconds for this thread to die. A timeout of 0 means to wait forever.
		T.join(100);
 
		//start my thread
		T.start();
 
		while(T.isAlive());
 
		//if I received my ACK, return TRUE else FALSE
		if(id==integer.intValue()) return true;
		else return false;		
	} //waitForACK()
 
	/**
         * This method is used by the thread
         */
	public void run() {
		 try {
			 integer = (Integer)PacketsReceptor.packetReceived(messageMessage);
			 interrupt();
		 }
		 catch(FileNotFoundException fnfe) {System.out.println(fnfe);}
		 catch(IOException ioe) {System.out.println(ioe);}
		 catch(InterruptedException ie) {System.out.println(ie);}
	}// run()
}// Class WaitForAcknowledgement

P.S. ne faites attention à mon anglais qui est des plus limité :oops:

je viens d'affiner mon code mais ce n'est pas encore cela...mais je pense m'approcher de la solution.

Code:

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
public class WaitForAcknowledgement extends Thread {
	/**
         * This method will wait while an ACK isn't received
         * @return true if ID acknowledgement received is the same that ID packet sent 
         */
 
	private static Integer integer = -1;
	private static Message messageMessage;
	private static boolean timeToReturn = false;
 
	/**
         * Constructor
         * @param message
         */
	WaitForAcknowledgement (Message message) {
		messageMessage = message;
	}// WaitForAcknowledgement (Message)
 
	/**
         * Method who will wait each ACK
         * @param id the last packet Id
         * @param message This object Message is used only to get network parameter
         * @return a boolean: TRUE if Id ack packet and Id data packet is same, otherwise FALSE
         * @throws FileNotFoundException
         * @throws IOException
         * @throws InterruptedException
         */
	public static boolean waitForAck(int id, Message message)
	throws FileNotFoundException, IOException, InterruptedException {		
 
		//create my thread calling WaitForAcknowledgement class constructor
		//Thread T = new WaitForAcknowledgement(message);
 
		Thread TSet = new Thread() {
			public void run() {
				 try {
					 integer = (Integer)PacketsReceptor.packetReceived(messageMessage);
					 timeToReturn = true;
				 }
				 catch(FileNotFoundException fnfe) {System.out.println(fnfe);}
				 catch(IOException ioe) {System.out.println(ioe);}
				 catch(InterruptedException ie) {System.out.println(ie);}
			}// run()
		};
 
		Thread TWait = new Thread() {
			public void run() {
				 try {
					 sleep(100);
					 timeToReturn = true;
				 }
				 catch(InterruptedException ie) {System.out.println(ie);}
			}// run()
		};
 
		TSet.start();
		TWait.start();
		while(!timeToReturn){sleep(1);}
 
		if(TSet.isAlive())TSet.interrupt();
		if(TWait.isAlive())TWait.interrupt();
 
		//if I received my ACK, return TRUE else FALSE
		if(id==integer.intValue()) return true;
		else return false;		
	} //waitForACK()
}// Class WaitForAcknowledgement

et un truc comme ça ?

Code:

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
public class WaitForAcknowledgement extends Thread {
 
	private Integer ack;
	private Message message;
 
	WaitForAcknowledgement (Message message) {
		this.message = message;
	}
 
	public static boolean waitForAck(int id, Message message) {	
		Thread t = new WaitForAcknowledgement(message);
		t.start();
		try {
		  t.join(100);
		} catch (InterruptedException ex) {}
 
		return t.isAlive() == false && t.ack != null && t.ack.intValue() == id;
	}
 
	public void run() {
		 try {
			 ack = (Integer) PacketsReceptor.packetReceived(message);
		 }
		 catch(FileNotFoundException fnfe) {System.out.println(fnfe);}
		 catch(IOException ioe) {System.out.println(ioe);}
		 catch(InterruptedException ie) {System.out.println(ie);}
	}
}

02/12/2007, 12h35
s0l4r1s

Merci beaucoup :king:herve91:king:, ton code est exactement ce que je cherchais. En plus, il est clair, simple, et optimisé...encore merci :yaisse2: