Interesting producer and consumer problems

Reprinted please indicate the source: http://blog.csdn.net/sunyujia/

The questions raised by netizens on the Forum can only be consumed for each 3 production sites. It is not difficult to do this for the sake of convenience.

Modified on the basis of the original http://blog.csdn.net/sunyujia/archive/2008/05/02/2362015.aspx.

The only difficulty is that three production threads are not the same. The two threads consumed are not the same thread. That is to say, it cannot be a thread that produces three in a row, and one thread consumes two in a row. If it is a thread that produces continuously, the program will be boring.

1. Import java. util. arraylist;
2. Import java. util. List;
3. Import java. util. Concurrent. executorservice;
4. Import java. util. Concurrent. executors;
6. /**
7. * Interesting producer and consumer problems
8. * Two shards are consumed for each generation of three shards.
9. * @ Author: sunyujia
10. * @ Blog: http://blog.csdn.net/sunyujia/
11. * @ Mail: sunyujia @ sunyujia@yahoo.cn
12. */
13. Public class executorservicetest {
14. Private Static int producecount = 0;
15. Private Static int consumecount = 0;
16. Private Static object producelock = new object ();
17. Private Static object consumelock = new object ();
19. Public static void main (string [] ARGs ){
20. Final list tasks = new arraylist ();
21. System. Out. println ("myblog: http://blog.csdn.net/" + "sunyujia /");
22. Final executorservice exec = executors. newcachedthreadpool ();
23. For (INT I = 0; I <10; I ++) {// 10 producers
24. Exec.exe cute (New runnable (){
25. Public void run (){
26. While (! Thread. interrupted ()){
27. Try {
28. Synchronized (consumelock ){
29. If (producecount> = 3)
30. Consumelock. Wait ();
31. }
32. Synchronized (producelock ){
33. If (producecount <3 ){
34. Tasks. Add (new object (); // Production
35. System. Out. println (thread. currentthread (). getname () + "remaining production tasks:" + tasks. Size ());
36. Producecount ++;
37. If (producecount> = 3 ){
38. Consumecount = 2; // you are prompted to consume only two
39. System. Out. println ("producer reminder inventory now"
40. + Tasks. Size ());
41. Producelock. policyall ();
42. }
43. Thread. Yield ();
44. }
45. }
46. Thread. Sleep (600); // Let the program run slowly for observation
47. } Catch (interruptedexception e ){
48. E. printstacktrace ();
49. }
50. }
51. }
52. });
53. }
54. For (INT I = 0; I <20; I ++) {// 20 consumers
55. Exec.exe cute (New runnable (){
56. Public void run (){
57. While (! Thread. interrupted ()){
58. Try {
59. Synchronized (producelock ){
60. If (consumecount <= 0)
61. Producelock. Wait ();
62. }
63. Synchronized (consumelock ){
64. If (consumecount> 0 ){
65. Tasks. Remove (0); // consume
66. System. Out. println (thread. currentthread (). getname () + "remaining tasks :"
67. + Tasks. Size ());
68. Consumecount --;
69. If (consumecount <= 0 ){
70. Producecount = 0; // three more are required
71. System. Out. println ("Consumer reminder inventory now"
72. + Tasks. Size ());
73. Consumelock. policyall ();
74. }
75. }
76. }
77. Thread. Sleep (600); // Let the program run slowly for observation
78. } Catch (interruptedexception e ){
79. E. printstacktrace ();
80. }
81. }
82. }
83. });
84. }
85. Exec. Shutdown ();
86. }
87. }

The execution result is as follows:
Pool-1-thread-1 production task remaining: 1
Pool-1-thread-2 production task remaining: 2
Pool-1-thread-4 production task remaining: 3
Producer friendly reminder current inventory 3
Pool-1-thread-11: 2
Pool-1-thread-12: 1
Consumer friendly reminder current inventory 1
Pool-1-thread-5 production task remaining: 2
Pool-1-thread-6 production task remaining: 3
Pool-1-thread-7 production task left: 4
Producer reminder inventory 4
Pool-1-thread-14: 3
Pool-1-thread-16 remaining tasks: 2
Consumer reminder inventory 2
Pool-1-thread-3 production task remaining: 3
Pool-1-thread-2 production task left: 4
Pool-1-thread-4 production task remaining: 5
Producer friendly reminder inventory 5