【Java】生產者消費者模式的三種實現

原文地址：https://blog.csdn.net/u010983881/article/details/78554671

前言

生產者消費者問題是線程模型中的經典問題：生產者和消費者在同一時間段內共用同一存儲空間，生產者向空間裏生產數據，而消費者取走數據。

阻塞隊列就相當於一個緩衝區，平衡了生產者和消費者的處理能力。這個阻塞隊列就是用來給生產者和消費者解耦的。

wait/notify方法

首先，我們搞清楚Thread.sleep()方法和Object.wait()、Object.notify()方法的區別。根據這篇文章java sleep和wait的區別的疑惑?

1. sleep()是Thread類的方法；而wait()，notify()，notifyAll()是Object類中定義的方法；儘管這兩個方法都會影響線程的執行行爲，但是本質上是有區別的。

2. Thread.sleep()不會導致鎖行爲的改變，如果當前線程是擁有鎖的，那麼Thread.sleep()不會讓線程釋放鎖。如果能夠幫助你記憶的話，可以簡單認爲和鎖相關的方法都定義在Object類中，因此調用Thread.sleep()是不會影響鎖的相關行爲。

3. Thread.sleep和Object.wait都會暫停當前的線程，對於CPU資源來說，不管是哪種方式暫停的線程，都表示它暫時不再需要CPU的執行時間。OS會將執行時間分配給其它線程。區別是調用wait後，需要別的線程執行notify/notifyAll才能夠重新獲得CPU執行時間。

線程狀態圖：

• Thread.sleep()讓線程從 【running】 -> 【阻塞態】 時間結束/interrupt -> 【runnable】
• Object.wait()讓線程從 【running】 -> 【等待隊列】notify -> 【鎖池】 -> 【runnable】

實現生產者消費者模型

生產者消費者問題是研究多線程程序時繞不開的經典問題之一，它描述是有一塊緩衝區作爲倉庫，生產者可以將產品放入倉庫，消費者則可以從倉庫中取走產品。在Java中一共有四種方法支持同步，其中前三個是同步方法，一個是管道方法。

（1）Object的wait() / notify()方法 
（2）Lock和Condition的await() / signal()方法 
（3）BlockingQueue阻塞隊列方法 
（4）PipedInputStream / PipedOutputStream

本文只介紹最常用的前三種，第四種暫不做討論。源代碼在這裏：Java實現生產者消費者模型

1. 使用Object的wait() / notify()方法

wait()/ nofity()方法是基類Object的兩個方法，也就意味着所有Java類都會擁有這兩個方法，這樣，我們就可以爲任何對象實現同步機制。

• wait()：當緩衝區已滿/空時，生產者/消費者線程停止自己的執行，放棄鎖，使自己處於等待狀態，讓其他線程執行。
• notify()：當生產者/消費者向緩衝區放入/取出一個產品時，向其他等待的線程發出可執行的通知，同時放棄鎖，使自己處於等待狀態。

1. /**

2. * 生產者消費者模式：使用Object.wait() / notify()方法實現

3. */

4. public class ProducerConsumer {

5. private static final int CAPACITY = 5;

6.  

7. public static void main(String args[]){

8. Queue<Integer> queue = new LinkedList<Integer>();

9.  

10. Thread producer1 = new Producer("P-1", queue, CAPACITY);

11. Thread producer2 = new Producer("P-2", queue, CAPACITY);

12. Thread consumer1 = new Consumer("C1", queue, CAPACITY);

13. Thread consumer2 = new Consumer("C2", queue, CAPACITY);

14. Thread consumer3 = new Consumer("C3", queue, CAPACITY);

15.  

16. producer1.start();

17. producer2.start();

18. consumer1.start();

19. consumer2.start();

20. consumer3.start();

21. }

22.  

23. /**

24. * 生產者

25. */

26. public static class Producer extends Thread{

27. private Queue<Integer> queue;

28. String name;

29. int maxSize;

30. int i = 0;

31.  

32. public Producer(String name, Queue<Integer> queue, int maxSize){

33. super(name);

34. this.name = name;

35. this.queue = queue;

36. this.maxSize = maxSize;

37. }

38.  

39. @Override

40. public void run(){

41. while(true){

42. synchronized(queue){

43. while(queue.size() == maxSize){

44. try {

45. System.out .println("Queue is full, Producer[" + name + "] thread waiting for " + "consumer to take something from queue.");

46. queue.wait();

47. } catch (Exception ex) {

48. ex.printStackTrace();

49. }

50. }

51. System.out.println("[" + name + "] Producing value : +" + i);

52. queue.offer(i++);

53. queue.notifyAll();

54.  

55. try {

56. Thread.sleep(new Random().nextInt(1000));

57. } catch (InterruptedException e) {

58. e.printStackTrace();

59. }

60. }

61. }

62.  

63. }

64. }

65.  

66. /**

67. * 消費者

68. */

69. public static class Consumer extends Thread{

70. private Queue<Integer> queue;

71. String name;

72. int maxSize;

73.  

74. public Consumer(String name, Queue<Integer> queue, int maxSize){

75. super(name);

76. this.name = name;

77. this.queue = queue;

78. this.maxSize = maxSize;

79. }

80.  

81. @Override

82. public void run(){

83. while(true){

84. synchronized(queue){

85. while(queue.isEmpty()){

86. try {

87. System.out.println("Queue is empty, Consumer[" + name + "] thread is waiting for Producer");

88. queue.wait();

89. } catch (Exception ex) {

90. ex.printStackTrace();

91. }

92. }

93. int x = queue.poll();

94. System.out.println("[" + name + "] Consuming value : " + x);

95. queue.notifyAll();

96.  

97. try {

98. Thread.sleep(new Random().nextInt(1000));

99. } catch (InterruptedException e) {

100. e.printStackTrace();

101. }

102. }

103. }

104. }

105. }

106. }

注意要點

判斷Queue大小爲0或者大於等於queueSize時須使用 while (condition) {}，不能使用 if(condition) {}。其中 while(condition)循環，它又被叫做“自旋鎖”。自旋鎖以及wait()和notify()方法在線程通信這篇文章中有更加詳細的介紹。爲防止該線程沒有收到notify()調用也從wait()中返回（也稱作虛假喚醒），這個線程會重新去檢查condition條件以決定當前是否可以安全地繼續執行還是需要重新保持等待，而不是認爲線程被喚醒了就可以安全地繼續執行了。

輸出日誌如下：

1. [P-1] Producing value : +0

2. [P-1] Producing value : +1

3. [P-1] Producing value : +2

4. [P-1] Producing value : +3

5. [P-1] Producing value : +4

6. Queue is full, Producer[P-1] thread waiting for consumer to take something from queue.

7. [C3] Consuming value : 0

8. [C3] Consuming value : 1

9. [C3] Consuming value : 2

10. [C3] Consuming value : 3

11. [C3] Consuming value : 4

12. Queue is empty, Consumer[C3] thread is waiting for Producer

13. Queue is empty, Consumer[C2] thread is waiting for Producer

14. Queue is empty, Consumer[C1] thread is waiting for Producer

15. [P-2] Producing value : +0

16. [C1] Consuming value : 0

17. Queue is empty, Consumer[C1] thread is waiting for Producer

18. Queue is empty, Consumer[C2] thread is waiting for Producer

19. Queue is empty, Consumer[C3] thread is waiting for Producer

20. [P-1] Producing value : +5

21. [P-1] Producing value : +6

22. [P-1] Producing value : +7

23. [P-1] Producing value : +8

24. [P-1] Producing value : +9

25. Queue is full, Producer[P-1] thread waiting for consumer to take something from queue.

26. [C3] Consuming value : 5

27. [C3] Consuming value : 6

28. [C3] Consuming value : 7

29. [C3] Consuming value : 8

30. [C3] Consuming value : 9

31. Queue is empty, Consumer[C3] thread is waiting for Producer

32. Queue is empty, Consumer[C2] thread is waiting for Producer

33. Queue is empty, Consumer[C1] thread is waiting for Producer

34. [P-2] Producing value : +1

35. [C1] Consuming value : 1

36. Queue is empty, Consumer[C1] thread is waiting for Producer

37. Queue is empty, Consumer[C2] thread is waiting for Producer

38. Queue is empty, Consumer[C3] thread is waiting for Producer

39. [P-1] Producing value : +10

40. [P-1] Producing value : +11

41. [P-1] Producing value : +12

42. [P-1] Producing value : +13

43. [P-1] Producing value : +14

44. Queue is full, Producer[P-1] thread waiting for consumer to take something from queue.

45. [C3] Consuming value : 10

46. [C3] Consuming value : 11

47. [C3] Consuming value : 12

48. [C3] Consuming value : 13

49. [C3] Consuming value : 14

50. Queue is empty, Consumer[C3] thread is waiting for Producer

51. Queue is empty, Consumer[C2] thread is waiting for Producer

52. Queue is empty, Consumer[C1] thread is waiting for Producer

53. [P-2] Producing value : +2

54. [P-2] Producing value : +3

55. [P-2] Producing value : +4

56. [P-2] Producing value : +5

57. [P-2] Producing value : +6

58. Queue is full, Producer[P-2] thread waiting for consumer to take something from queue.

59. [C1] Consuming value : 2

60. [C1] Consuming value : 3

61. [C1] Consuming value : 4

62. [C1] Consuming value : 5

63. [C1] Consuming value : 6

64. Queue is empty, Consumer[C1] thread is waiting for Producer

65. Queue is empty, Consumer[C2] thread is waiting for Producer

66. Queue is empty, Consumer[C3] thread is waiting for Producer

67. [P-1] Producing value : +15

68. [C3] Consuming value : 15

69. Queue is empty, Consumer[C3] thread is waiting for Producer

70. Queue is empty, Consumer[C2] thread is waiting for Producer

71. Queue is empty, Consumer[C1] thread is waiting for Producer

72. [P-2] Producing value : +7

73. [P-2] Producing value : +8

74. [P-2] Producing value : +9

2. 使用Lock和Condition的await() / signal()方法

在JDK5.0之後，Java提供了更加健壯的線程處理機制，包括同步、鎖定、線程池等，它們可以實現更細粒度的線程控制。Condition接口的await()和signal()就是其中用來做同步的兩種方法，它們的功能基本上和Object的wait()/ nofity()相同，完全可以取代它們，但是它們和新引入的鎖定機制Lock直接掛鉤，具有更大的靈活性。通過在Lock對象上調用newCondition()方法，將條件變量和一個鎖對象進行綁定，進而控制併發程序訪問競爭資源的安全。下面來看代碼：

1. /**

2. * 生產者消費者模式：使用Lock和Condition實現

3. * {@link java.util.concurrent.locks.Lock}

4. * {@link java.util.concurrent.locks.Condition}

5. */

6. public class ProducerConsumerByLock {

7. private static final int CAPACITY = 5;

8. private static final Lock lock = new ReentrantLock();

9. private static final Condition fullCondition = lock.newCondition(); //隊列滿的條件

10. private static final Condition emptyCondition = lock.newCondition(); //隊列空的條件

11.  
12.  

13. public static void main(String args[]){

14. Queue<Integer> queue = new LinkedList<Integer>();

15.  

16. Thread producer1 = new Producer("P-1", queue, CAPACITY);

17. Thread producer2 = new Producer("P-2", queue, CAPACITY);

18. Thread consumer1 = new Consumer("C1", queue, CAPACITY);

19. Thread consumer2 = new Consumer("C2", queue, CAPACITY);

20. Thread consumer3 = new Consumer("C3", queue, CAPACITY);

21.  

22. producer1.start();

23. producer2.start();

24. consumer1.start();

25. consumer2.start();

26. consumer3.start();

27. }

28.  

29. /**

30. * 生產者

31. */

32. public static class Producer extends Thread{

33. private Queue<Integer> queue;

34. String name;

35. int maxSize;

36. int i = 0;

37.  

38. public Producer(String name, Queue<Integer> queue, int maxSize){

39. super(name);

40. this.name = name;

41. this.queue = queue;

42. this.maxSize = maxSize;

43. }

44.  

45. @Override

46. public void run(){

47. while(true){

48.  

49. //獲得鎖

50. lock.lock();

51. while(queue.size() == maxSize){

52. try {

53. System.out .println("Queue is full, Producer[" + name + "] thread waiting for " + "consumer to take something from queue.");

54. //條件不滿足，生產阻塞

55. fullCondition.await();

56. } catch (InterruptedException ex) {

57. ex.printStackTrace();

58. }

59. }

60. System.out.println("[" + name + "] Producing value : +" + i);

61. queue.offer(i++);

62.  

63. //喚醒其他所有生產者、消費者

64. fullCondition.signalAll();

65. emptyCondition.signalAll();

66.  

67. //釋放鎖

68. lock.unlock();

69.  

70. try {

71. Thread.sleep(new Random().nextInt(1000));

72. } catch (InterruptedException e) {

73. e.printStackTrace();

74. }

75. }

76.  

77. }

78. }

79.  

80. /**

81. * 消費者

82. */

83. public static class Consumer extends Thread{

84. private Queue<Integer> queue;

85. String name;

86. int maxSize;

87.  

88. public Consumer(String name, Queue<Integer> queue, int maxSize){

89. super(name);

90. this.name = name;

91. this.queue = queue;

92. this.maxSize = maxSize;

93. }

94.  

95. @Override

96. public void run(){

97. while(true){

98. //獲得鎖

99. lock.lock();

100.  

101. while(queue.isEmpty()){

102. try {

103. System.out.println("Queue is empty, Consumer[" + name + "] thread is waiting for Producer");

104. //條件不滿足，消費阻塞

105. emptyCondition.await();

106. } catch (Exception ex) {

107. ex.printStackTrace();

108. }

109. }

110. int x = queue.poll();

111. System.out.println("[" + name + "] Consuming value : " + x);

112.  

113. //喚醒其他所有生產者、消費者

114. fullCondition.signalAll();

115. emptyCondition.signalAll();

116.  

117. //釋放鎖

118. lock.unlock();

119.  

120. try {

121. Thread.sleep(new Random().nextInt(1000));

122. } catch (InterruptedException e) {

123. e.printStackTrace();

124. }

125. }

126. }

127. }

128. }

輸入日誌如下：

1. [P-1] Producing value : +0

2. [C1] Consuming value : 0

3. Queue is empty, Consumer[C3] thread is waiting for Producer

4. Queue is empty, Consumer[C2] thread is waiting for Producer

5. [P-2] Producing value : +0

6. [C3] Consuming value : 0

7. Queue is empty, Consumer[C2] thread is waiting for Producer

8. Queue is empty, Consumer[C1] thread is waiting for Producer

9. [P-2] Producing value : +1

10. [C2] Consuming value : 1

11. Queue is empty, Consumer[C1] thread is waiting for Producer

12. Queue is empty, Consumer[C3] thread is waiting for Producer

13. [P-1] Producing value : +1

14. [C1] Consuming value : 1

15. Queue is empty, Consumer[C3] thread is waiting for Producer

16. [P-1] Producing value : +2

17. [C3] Consuming value : 2

18. Queue is empty, Consumer[C2] thread is waiting for Producer

19. [P-2] Producing value : +2

20. [C2] Consuming value : 2

21. Queue is empty, Consumer[C1] thread is waiting for Producer

22. Queue is empty, Consumer[C2] thread is waiting for Producer

23. [P-1] Producing value : +3

24. [C1] Consuming value : 3

25. Queue is empty, Consumer[C2] thread is waiting for Producer

26. Queue is empty, Consumer[C1] thread is waiting for Producer

27. Queue is empty, Consumer[C3] thread is waiting for Producer

28. [P-2] Producing value : +3

29. [C2] Consuming value : 3

30. Queue is empty, Consumer[C1] thread is waiting for Producer

31. Queue is empty, Consumer[C3] thread is waiting for Producer

32. Queue is empty, Consumer[C2] thread is waiting for Producer

33. [P-1] Producing value : +4

34. [C1] Consuming value : 4

35. Queue is empty, Consumer[C3] thread is waiting for Producer

36. Queue is empty, Consumer[C2] thread is waiting for Producer

37. Queue is empty, Consumer[C1] thread is waiting for Producer

38. [P-2] Producing value : +4

39. [C3] Consuming value : 4

40. Queue is empty, Consumer[C2] thread is waiting for Producer

41. Queue is empty, Consumer[C1] thread is waiting for Producer

42. [P-2] Producing value : +5

43. [C2] Consuming value : 5

44. Queue is empty, Consumer[C1] thread is waiting for Producer

45. Queue is empty, Consumer[C2] thread is waiting for Producer

46. [P-1] Producing value : +5

47. [C1] Consuming value : 5

48. Queue is empty, Consumer[C2] thread is waiting for Producer

49. Queue is empty, Consumer[C3] thread is waiting for Producer

50. [P-2] Producing value : +6

51. [C2] Consuming value : 6

52. Queue is empty, Consumer[C3] thread is waiting for Producer

53. [P-1] Producing value : +6

54. [C3] Consuming value : 6

55. Queue is empty, Consumer[C3] thread is waiting for Producer

56. Queue is empty, Consumer[C1] thread is waiting for Producer

57. [P-2] Producing value : +7

58. [C3] Consuming value : 7

59. Queue is empty, Consumer[C1] thread is waiting for Producer

60. [P-1] Producing value : +7

61. [C1] Consuming value : 7

62. Queue is empty, Consumer[C2] thread is waiting for Producer

63. [P-2] Producing value : +8

64. [C2] Consuming value : 8

65. [P-1] Producing value : +8

66. [C1] Consuming value : 8

67. [P-2] Producing value : +9

68. [C3] Consuming value : 9

69. [P-2] Producing value : +10

70. [C2] Consuming value : 10

71. [P-1] Producing value : +9

72. [P-1] Producing value : +10

73. [C1] Consuming value : 9

74. [P-2] Producing value : +11

75. [C3] Consuming value : 10

76. [C2] Consuming value : 11

77. [P-2] Producing value : +12

78. [C1] Consuming value : 12

79. [P-1] Producing value : +11

80. [C3] Consuming value : 11

81. [P-2] Producing value : +13

82. [C2] Consuming value : 13

83. Queue is empty, Consumer[C2] thread is waiting for Producer

84. Queue is empty, Consumer[C3] thread is waiting for Producer

85. [P-1] Producing value : +12

86. [C2] Consuming value : 12

87. Queue is empty, Consumer[C3] thread is waiting for Producer

88. [P-1] Producing value : +13

89. [C3] Consuming value : 13

90. Queue is empty, Consumer[C1] thread is waiting for Producer

91. Queue is empty, Consumer[C3] thread is waiting for Producer

92. [P-2] Producing value : +14

93. [C1] Consuming value : 14

94. Queue is empty, Consumer[C3] thread is waiting for Producer

95. Queue is empty, Consumer[C1] thread is waiting for Producer

96. [P-1] Producing value : +14

97. [C3] Consuming value : 14

98. Queue is empty, Consumer[C1] thread is waiting for Producer

99. [P-1] Producing value : +15

100. [C1] Consuming value : 15

101. [P-2] Producing value : +15

102. [P-1] Producing value : +16

103. [C3] Consuming value : 15

104. [P-2] Producing value : +16

3. 使用BlockingQueue阻塞隊列方法

JDK 1.5 以後新增的 java.util.concurrent包新增了 BlockingQueue 接口。並提供瞭如下幾種阻塞隊列實現：

• java.util.concurrent.ArrayBlockingQueue
• java.util.concurrent.LinkedBlockingQueue
• java.util.concurrent.SynchronousQueue
• java.util.concurrent.PriorityBlockingQueue

實現生產者-消費者模型使用 ArrayBlockingQueue或者 LinkedBlockingQueue即可。

我們這裏使用LinkedBlockingQueue，它是一個已經在內部實現了同步的隊列，實現方式採用的是我們第2種await()/ signal()方法。它可以在生成對象時指定容量大小。它用於阻塞操作的是put()和take()方法。

• put()方法：類似於我們上面的生產者線程，容量達到最大時，自動阻塞。
• take()方法：類似於我們上面的消費者線程，容量爲0時，自動阻塞。

我們可以跟進源碼看一下LinkedBlockingQueue類的put()方法實現：

1. /** Main lock guarding all access */

2. final ReentrantLock lock = new ReentrantLock();

3.  

4. /** Condition for waiting takes */

5. private final Condition notEmpty = lock.newCondition();

6.  

7. /** Condition for waiting puts */

8. private final Condition notFull = lock.newCondition();

9.  
10.  
11.  

12. public void put(E e) throws InterruptedException {

13. putLast(e);

14. }

15.  

16. public void putLast(E e) throws InterruptedException {

17. if (e == null) throw new NullPointerException();

18. Node<E> node = new Node<E>(e);

19. final ReentrantLock lock = this.lock;

20. lock.lock();

21. try {

22. while (!linkLast(node))

23. notFull.await();

24. } finally {

25. lock.unlock();

26. }

27. }

看到這裏證實了它的實現方式採用的是我們第2種await()/ signal()方法。下面我們就使用它實現吧。

1. /**

2. * 生產者消費者模式：使用{@link java.util.concurrent.BlockingQueue}實現

3. */

4. public class ProducerConsumerByBQ{

5. private static final int CAPACITY = 5;

6.  

7. public static void main(String args[]){

8. LinkedBlockingDeque<Integer> blockingQueue = new LinkedBlockingDeque<Integer>(CAPACITY);

9.  

10. Thread producer1 = new Producer("P-1", blockingQueue, CAPACITY);

11. Thread producer2 = new Producer("P-2", blockingQueue, CAPACITY);

12. Thread consumer1 = new Consumer("C1", blockingQueue, CAPACITY);

13. Thread consumer2 = new Consumer("C2", blockingQueue, CAPACITY);

14. Thread consumer3 = new Consumer("C3", blockingQueue, CAPACITY);

15.  

16. producer1.start();

17. producer2.start();

18. consumer1.start();

19. consumer2.start();

20. consumer3.start();

21. }

22.  

23. /**

24. * 生產者

25. */

26. public static class Producer extends Thread{

27. private LinkedBlockingDeque<Integer> blockingQueue;

28. String name;

29. int maxSize;

30. int i = 0;

31.  

32. public Producer(String name, LinkedBlockingDeque<Integer> queue, int maxSize){

33. super(name);

34. this.name = name;

35. this.blockingQueue = queue;

36. this.maxSize = maxSize;

37. }

38.  

39. @Override

40. public void run(){

41. while(true){

42. try {

43. blockingQueue.put(i);

44. System.out.println("[" + name + "] Producing value : +" + i);

45. i++;

46.  

47. //暫停最多1秒

48. Thread.sleep(new Random().nextInt(1000));

49. } catch (InterruptedException e) {

50. e.printStackTrace();

51. }

52. }

53.  

54. }

55. }

56.  

57. /**

58. * 消費者

59. */

60. public static class Consumer extends Thread{

61. private LinkedBlockingDeque<Integer> blockingQueue;

62. String name;

63. int maxSize;

64.  

65. public Consumer(String name, LinkedBlockingDeque<Integer> queue, int maxSize){

66. super(name);

67. this.name = name;

68. this.blockingQueue = queue;

69. this.maxSize = maxSize;

70. }

71.  

72. @Override

73. public void run(){

74. while(true){

75. try {

76. int x = blockingQueue.take();

77. System.out.println("[" + name + "] Consuming : " + x);

78.  

79. //暫停最多1秒

80. Thread.sleep(new Random().nextInt(1000));

81. } catch (InterruptedException e) {

82. e.printStackTrace();

83. }

84. }

85. }

86. }

87. }

輸出日誌如下：

1. [P-2] Producing value : +0

2. [P-1] Producing value : +0

3. [C1] Consuming : 0

4. [C3] Consuming : 0

5. [P-2] Producing value : +1

6. [C2] Consuming : 1

7. [P-2] Producing value : +2

8. [C1] Consuming : 2

9. [P-1] Producing value : +1

10. [C2] Consuming : 1

11. [P-1] Producing value : +2

12. [C3] Consuming : 2

13. [P-1] Producing value : +3

14. [C2] Consuming : 3

15. [P-2] Producing value : +3

16. [C1] Consuming : 3

17. [P-1] Producing value : +4

18. [C2] Consuming : 4

19. [P-2] Producing value : +4

20. [C3] Consuming : 4

21. [P-2] Producing value : +5

22. [C1] Consuming : 5

23. [P-1] Producing value : +5

24. [C2] Consuming : 5

25. [P-1] Producing value : +6

26. [C1] Consuming : 6

27. [P-2] Producing value : +6

28. [C2] Consuming : 6

29. [P-2] Producing value : +7

30. [C2] Consuming : 7

31. [P-1] Producing value : +7

32. [C1] Consuming : 7

33. [P-2] Producing value : +8

34. [C3] Consuming : 8

35. [P-2] Producing value : +9

36. [C2] Consuming : 9

37. [P-1] Producing value : +8

38. [C2] Consuming : 8

39. [P-2] Producing value : +10

40. [C1] Consuming : 10

41. [P-1] Producing value : +9

42. [C3] Consuming : 9

43. [P-1] Producing value : +10

44. [C2] Consuming : 10

45. [P-2] Producing value : +11

46. [C1] Consuming : 11

47. [C3] Consuming : 12

48. [P-2] Producing value : +12

49. [P-2] Producing value : +13

50. [C2] Consuming : 13

51. [P-1] Producing value : +11

52. [C3] Consuming : 11

53. [P-1] Producing value : +12

54. [C3] Consuming : 12

55. [P-2] Producing value : +14

56. [C1] Consuming : 14

57. [P-1] Producing value : +13

58. [C2] Consuming : 13

59. [P-2] Producing value : +15

60. [C3] Consuming : 15

61. [P-2] Producing value : +16

62. [C1] Consuming : 16

63. [P-1] Producing value : +14

64. [C3] Consuming : 14

65. [P-2] Producing value : +17

66. [C2] Consuming : 17

參考資料

• Producer-Consumer solution using threads in Java
• 生產者消費者問題 - 維基百科
• 生產者/消費者問題的多種Java實現方式
• 如何在 Java 中正確使用 wait, notify 和 notifyAll – 以生產者消費者模型爲例
• JAVA多線程之wait/notify
• java sleep和wait的區別的疑惑