[Thread] wait and notify

Bonjour,

je viens de créer deux petites classes en utilisant wait and notify. Cependant je pense que je peux l'améliorer en passant par les classes de programmations concurrante de Java 5 mais je n'y arrive pas. Voilà mes deux classes :

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
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
import java.util.ArrayList;
import java.util.List;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class SimpleStateThread extends Thread implements IStateThread {
 
	private Logger logger = LoggerFactory.getLogger(SimpleStateThread.class);
 
	private ThreadEvent.ThreadState state;
 
	private List<IThreadListener> listeners;
 
	private Runnable task;
 
	private Object waitingMutex = new Object();
 
	private Object killMutex = new Object();
 
	private boolean killFlag = false;
 
	private boolean startFlag = false;
 
	private boolean killTermSignal = false;
 
	public SimpleStateThread() {
		this.state = ThreadEvent.ThreadState.NEW;
		listeners = new ArrayList<IThreadListener>();
	}
 
	@Override
	public synchronized void addTask(Runnable task) {
		synchronized (waitingMutex) {
			if (this.task == null && task != null) {
				this.task = task;
				waitingMutex.notify();
			}
		}
	}
 
	@Override
	public void addThreadListener(IThreadListener listener) {
		listeners.add(listener);
	}
 
	@Override
	public synchronized void kill() {
		if (killTermSignal) {
 
		} else if (!startFlag) {
			logger.error("Il faut déjà lancer le thread pour le tuer.");
		} else {
			killTermSignal = true;
			synchronized (killMutex) {
				if (!killFlag) {
					try {
						killFlag = true;
						logger.debug("Kill signal wait.");
						killMutex.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				} else {
					killMutex.notify();
				}
			}
		}
	}
 
	@Override
	public synchronized void launch() {
		if (startFlag) {
			logger.error("Il thread a déjà été lancé.");
		} else {
			startFlag = true;
			start();
		}
	}
 
	private void notify(ThreadEvent.ThreadState state) {
		for (IThreadListener l : listeners) {
			l.stateChanged(new ThreadEvent(this.state, state, this));
		}
		this.state = state;
	}
 
	@Override
	public void removeThreadListener(IThreadListener listener) {
		listeners.remove(listener);
	}
 
	@Override
	public void run() {
		notify(ThreadEvent.ThreadState.CREATED);
 
		synchronized (waitingMutex) {
			if (task == null) {
				try {
					notify(ThreadEvent.ThreadState.WAIT);
					waitingMutex.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
 
		notify(ThreadEvent.ThreadState.EXECUTE);
		task.run();
 
		synchronized (killMutex) {
			if (!killFlag) {
				try {
					killFlag = true;
					notify(ThreadEvent.ThreadState.WAIT_KILL);
					killMutex.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} else {
				notify(ThreadEvent.ThreadState.KILL_NOW);
				killMutex.notify();
			}
 
		}
 
		notify(ThreadEvent.ThreadState.DEAD);
	}
 
}

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
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
import java.util.ArrayList;
import java.util.List;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class MultiTaskStateThread extends Thread implements IStateThread {
 
	private boolean killFlag = false ;
 
	private Object killMutex = new Object();
 
	private List<IThreadListener> listeners;
 
	private Logger logger = LoggerFactory.getLogger(SimpleStateThread.class);
 
	private boolean startFlag = false;
 
	private ThreadEvent.ThreadState state;
 
	private boolean stopSignal = false ;
 
	private List<Runnable> tasks;
 
	private Object waitingMutex = new Object();
 
	public MultiTaskStateThread() {
		this.state = ThreadEvent.ThreadState.NEW;
		listeners = new ArrayList<IThreadListener>();
		tasks = new ArrayList<Runnable>();
	}
 
	@Override
	public void addTask(Runnable task) {
		synchronized (waitingMutex) {
			if (task != null) {
				tasks.add(task);
				waitingMutex.notify();
			}
		}
	}
 
	@Override
	public void addThreadListener(IThreadListener listener) {
		listeners.add(listener);
	}
 
	@Override
	public void kill() {
		synchronized (waitingMutex) {
			stopSignal = true ;
			waitingMutex.notify();
		}
		synchronized (killMutex) {
			if (!killFlag) {
				try {
					killFlag = true;
					killMutex.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} else {
				killMutex.notify();
			}
		}			
	}
 
	@Override
	public void launch() {
		if (startFlag) {
			logger.error("Il thread a déjà été lancé.");
		} else {
			startFlag = true;
			start();
		}
	}
 
	private void notify(ThreadEvent.ThreadState state) {
		for (IThreadListener l : listeners) {
			l.stateChanged(new ThreadEvent(this.state, state, this));
		}
		this.state = state;
	}
 
	@Override
	public void removeThreadListener(IThreadListener listener) {
		listeners.remove(listener);
	}
 
	@Override
	public void run() {
		notify(ThreadEvent.ThreadState.CREATED);
		while(true){
			Runnable task = null ;
			synchronized (waitingMutex) {
				if( tasks.size() == 0 ) {
					if(stopSignal){
						notify(ThreadEvent.ThreadState.KILL_NOW);
						break;
					}
					notify(ThreadEvent.ThreadState.WAIT);
					waitingMutex.notify();					
				}  else {
					task = tasks.remove(0) ;
				}
			}
			if(task!=null){
				notify(ThreadEvent.ThreadState.EXECUTE);
				task.run();
			}
		}
 
		synchronized (killMutex) {
			if (!killFlag) {
				try {
					killFlag = true;
					killMutex.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} else {
				killMutex.notify();
			}
 
		}		
 
		notify(ThreadEvent.ThreadState.DEAD);
	}
 
 
}

merci de votre aide.