BlockingQueue实现生产者-消费者模式

生产者-消费者模式是以缓冲区为协作的桥梁，生产者只需要负责生产，并把生产的消息放入缓冲区，不用管有多少生产者和消费者，而消费者只需要负责取出缓冲区里的消息来消费，也不需要管有多少消费者和生产者。

而BlockingQueue很好的解决了如何将一个线程收集的消息传递给另一线程用于处理的问题，并且不需要考虑同步问题。

下面为代码的实现：

 1 /**

 2  * 

 3  */

 4 package bells;

 5 

 6 import java.util.Arrays;

 7 import java.util.List;

 8 import java.util.concurrent.ArrayBlockingQueue;

 9 import java.util.concurrent.BlockingQueue;

10 

11 /**

12  * 生产者

13  * 

14  * @author bellszhu

15  * 

16  */

17 class Procuder implements Runnable {

18 

19     private BlockingQueue<String> queue;

20 

21     public Procuder(BlockingQueue<String> queue) {

22         this.queue = queue;

23     }

24 

25     @Override

26     public void run() {

27         try {

28             for (String message : produceMessages()) {

29                 queue.put(message);

30             }

31         } catch (InterruptedException e) {

32             System.err.println("Interrupted! " + e.getMessage());

33         }

34     }

35 

36     /**

37      * 简单实现生产过程

38      * 

39      * @return

40      */

41     private List<String> produceMessages() {

42         return Arrays.asList("I'm coming", "I'm done it", "I'm win",

43                 "congratulate", "over");

44     }

45 }

46 

47 /**

48  * 消费者

49  * 

50  * @author bellszhu

51  * 

52  */

53 class Consumer implements Runnable {

54 

55     private BlockingQueue<String> queue;

56 

57     public Consumer(BlockingQueue<String> queue) {

58         this.queue = queue;

59     }

60 

61     @Override

62     public void run() {

63         try {

64             String message = null;

65             while (!((message = queue.take()).equals("over"))) {

66                 // 消费者处理消息

67                 System.out.println("Thread: " + Thread.currentThread().getId()

68                         + "\tmessage: " + message);

69             }

70         } catch (InterruptedException e) {

71             System.err.println("Interrupted! " + e.getMessage());

72         }

73     }

74 }

75 

76 /**

77  * @author bellszhu

78  * 

79  */

80 public class ProcuderConsumerTest {

81     public static void main(String[] args) {

82         BlockingQueue<String> queue = new ArrayBlockingQueue<String>(1, true);

83 

84         new Thread(new Procuder(queue)).start();

85 

86         new Thread(new Consumer(queue)).start();

87         new Thread(new Consumer(queue)).start();

88     }

89 }

 关于生产者-消费者模式的设计可以参考：http://blog.csdn.net/program_think/article/details/4022087