Java multi-thread consumer producer model

2. /* @author Shijin
4. * Producer and Consumer models, the following points must be ensured:
6. * 1 at the same time only one producer production method plus lock sychronized
8. * 2 at the same time can only have a consumer consumer spending method plus lock sychronized
10. * 3 producer production at the same time consumers can not consume production method lock sychronized
12. * 4 consumer consumption at the same time producers can not produce consumption method lock sychronized
14. * 5 Space when the consumer cannot continue to consume the consumption before the cycle to determine whether it is empty, empty the thread wait, release the lock allows other synchronization methods to execute
16. * 6 When the space is full, the producer cannot continue to produce production before the cycle determines whether it is full or full, wait for the thread, release the lock to allow other synchronization methods to execute
18. */
22. Main class
24. Class Producerconsumer
26. {
28. public static void Main (string[] args)
30. {
32. Stackbasket s = new Stackbasket ();
34. Producer p = new Producer (s);
36. Consumer C = new Consumer (s);
38. Thread TP = new Thread (p);
40. Thread TC = new Thread (c);
42. Tp.start ();
44. Tc.start ();
46. }
48. }
52. //
54. Class Mantou
56. {
58. private int id;
62. Mantou (int id) {
64. this.id = ID;
66. }
70. Public String toString () {
72. return "Mantou:" + ID;
74. }
76. }
80. Shared stack Space
82. Class Stackbasket
84. {
86. Mantou sm[] = new mantou[6];
88. int index = 0;
92. /**  
94. * Show Production method.
96. * Show this method is synchronous method, hold method lock;
98. * Show first cycle judgment full No, full words make the thread wait, release the Sync method lock, allow consumption;
100. * Show first wakes the waiting consumption method when dissatisfied, but also can only let it enter the ready state,
102. * Show etc production end release Sync method lock consumption to hold the lock for consumption
104. * @param m element
106. * @return No return value
108. */
112. public synchronized void push (Mantou m) {
114. try{
116. While (index = = sm.length) {
118. System.out.println ("!!!!!!!!! Production is full of!!!!!!!!! ");
120. this.wait ();
122. }
124. this.notify ();
126. }catch (Interruptedexception e) {
128. E.printstacktrace ();
130. }catch (Illegalmonitorstateexception e) {
132. E.printstacktrace ();
134. }
138. Sm[index] = m;
140. index++;
142. System.out.println ("produced:" + M + "Total" + index + "a steamed bun");
144. }
148. /**  
150. * Show Consumption method
152. * Show this method is synchronous method, hold method lock
154. * Show first loop to determine whether null, empty words make the thread wait, release the synchronous method lock, allow production;
156. * Show first wakes the waiting production method when it is not empty, but only allows it to enter the ready state
158. * Show and other consumption end release Sync method lock production to hold the lock for production
160. * @param b True indicates display, false means hidden
162. * @return No return value
164. */
166. public synchronized Mantou pop () {
168. try{
170. While (index = = 0) {
172. System.out.println ("!!!!!!!!! Consumption of Light!!!!!!!!! ");
174. this.wait ();
176. }
178. this.notify ();
180. }catch (Interruptedexception e) {
182. E.printstacktrace ();
184. }catch (Illegalmonitorstateexception e) {
186. E.printstacktrace ();
188. }
190. index--;
192. System.out.println ("consumption:---------" + sm[index] + "Total" + index + "a steamed bun");
194. return Sm[index];
196. }
198. }
202. Class Producer implements Runnable
204. {
206. Stackbasket ss = new Stackbasket ();
208. Producer (Stackbasket ss) {
210. THIS.SS = SS;
212. }
216. /**  
218. * Show production process.
220. */
222. public Void Run () {
224. For (int i = 0;i < 20;i++) {
226. Mantou m = new Mantou (i);
228. Ss.push (m);
230. System.out.println ("produced:" + M + "Total" + Ss.index + "a steamed bun");
232. It is inappropriate to test on the above line, and access to index should be in atomic operation, because it may be consumed before the output of the push, resulting in output confusion
234. try{
236. Thread.Sleep ((int) (Math.random () *500));
238. }catch (Interruptedexception e) {
240. E.printstacktrace ();
242. }
244. }
246. }
248. }
252. Class Consumer implements Runnable
254. {
256. Stackbasket ss = new Stackbasket ();
258. Consumer (Stackbasket ss) {
260. THIS.SS = SS;
262. }
266. /**  
268. * Show consumption process.
270. */
272. public Void Run () {
274. For (int i = 0;i < 20;i++) {
276. Mantou m = Ss.pop ();
278. System.out.println ("Consumption:---------" + M + "Total" + Ss.index + "a steamed bun");
280. It is not appropriate to test the above line in the above row, the access to index should be in the atomic operation, because it may be produced after the pop after this output, will produce output confusion
282. try{
284. Thread.Sleep ((int) (Math.random () *1000));
286. }catch (Interruptedexception e) {
288. E.printstacktrace ();
290. }
292. }
294. }
296. }

Java multi-thread consumer producer model