生产者消费者问题是Java并发中的常见问题之一，在实现时，一般可以考虑使用juc包下的BlockingQueue接口，至于具体使用哪个类，则就需要根据具体的使用场景具体分析了。本文主要实现一个生产者消费者的原型，以及实现一个生产者消费者的典型使用场景。

第一个问题：实现一个生产者消费者的原型。

 1 import java.util.concurrent.*;
 2 
 3 class Consumer implements Runnable {
 4     BlockingQueue q = null;
 5 
 6     public Consumer(BlockingQueue q) {
 7         this.q = q;
 8     }
 9 
10     @Override 
11     public void run() {
12         while(true) {
13             try {
14                 q.take();
15                 System.out.println("Consumer has taken a product.");
16             }catch(InterruptedException e) {
17     
18             }
19         }
20     }
21 }
22 
23 class Producer implements Runnable {
24     BlockingQueue q = null;
25     
26     public Producer(BlockingQueue q) {
27         this.q = q;
28     }
29 
30     @Override
31     public void run() {
32         while(true) {
33             try { // note that if there is any chance that block, usually we need a InterruptedException 34                 q.put(new Object());
35                 System.out.println("Producer has puted a product.");
36             }catch(InterruptedException e) {
37 
38             }
39         }
40     }
41 
42 
43 }
44 
45 public class JC_ProducerConsumerPrototype {
46     static int queueCapacity = 1024;
47     //static BlockingQueue<Object> q = new ArrayBlockingQueue<Object>(queueCapacity); // Can also compile
48     static BlockingQueue q = new ArrayBlockingQueue(queueCapacity); // ABQ must has a capacity 49     public static void main(String[] args) {
50         Thread t1 = new Thread(new Producer(q));
51         Thread t2 = new Thread(new Consumer(q));
52         t1.start();
53         t2.start();
54     }
55 
56 
57 }

第二个问题，现在假设生产者是在读取磁盘上的多个log文件，对于每一个文件，依次读取文件中的每一行，也就是一条log记录；消费者需要读取并分析这些记录，假设消费者是计算密集型的。如何在生产者消费者原型的基础上实现这些功能？

这个场景在server端开发中是经常碰到的，因为在Server端，不可避免地会产生大量的日志文件。

 1 import java.util.concurrent.*;
 2 import java.io.*;
 3 import java.nio.*;
 4 import java.nio.file.*;
 5 import java.util.*;
 6 import java.nio.charset.*;
 7 
 8 
 9 class Producer implements Runnable {
10     BlockingQueue q = null;
11     String fileName = null;
12     CountDownLatch latch = null;
13     
14     public Producer(BlockingQueue q,String fileName,CountDownLatch latch) {
15         this.q = q;
16         this.fileName = fileName;
17         this.latch = latch;
18     }
19 
20     @Override
21     public void run() {
22         Path path = Paths.get(".",fileName); 23         try{
24             List<String> lines = Files.readAllLines(path,StandardCharsets.UTF_8); 25             for(int i=lines.size();i>0;i--){
26                 try{
27                     q.put(lines.get(i));
28                 }catch(InterruptedException e) {
29 
30                 }
31             }
32         }catch(IOException e){
33 
34         }
35         latch.countDown();
36     }
37 }
38 
39 class Consumer implements Runnable {
40     BlockingQueue<String> q = null;
41     Boolean done = false;
42     
43     public Consumer(BlockingQueue q,Boolean done){
44         this.q = q;
45         this.done = done;
46     }
47 
48     @Override
49     public void run(){
50         while(!done||q.size()!=0){
51             try{
52                 q.take();
53             }catch(InterruptedException e){
54 
55             }
56         }
57     }
58 }
59 
60 public class JC_ProducerConsumerHandlingLog{
61     public static int fileCount = 1024;
62     public static String[] fileNames = new String[fileCount];
63     public static int cpuCount = 8;
64     public static CountDownLatch latch = new CountDownLatch(fileCount);
65     public static volatile boolean done = false;
66     public static BlockingQueue<String> q = new LinkedBlockingQueue<String>(fileCount);//one thread for one file 67 
68     public static void main(String[] args){
69         for(int i=0;i<fileCount;i++){
70             Thread t = new Thread(new Producer(q,fileNames[i],latch));
71             t.start();
72         }
73         for(int i=0;i<cpuCount;i++){//for computing tasks, we don't need too many threads. 74             Thread t = new Thread(new Consumer(q,done));
75             t.start();
76         }
77         try{
78             latch.await();
79             done = true;
80         }catch(InterruptedException e){
81 
82         }
83 
84     }
85 }

 需要稍微注意一下线程数的选择，对于计算密集型的任务，我认为线程数达到cpu的核数比较合理(在不考虑超线程的情况下，也就是说一个核只有一个线程)。有不同意见欢迎跟我交流！