Java多线程之通信_java线程通信缓冲区-CSDN博客

Java多线程之通信

在并发编程中，我们需要处理两个关键问题：线程之间如何通信及线程之间如何同步。通信是指线程之间以何种机制来交换信息。在命令式编程中，线程之间的通信机制有两种：共享内存和消息传递。

java内存模型

线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。

从上图来看，线程A与线程B之间如要通信的话，必须要经历下面2个步骤：

首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。
然后，线程B到主内存中去读取线程A之前已更新过的共享变量。

伦理片 http://www.dotdy.com/

另一种消息传递的方式

生产者、消费者模式

生产者：没有生产之前通知消费者等待，生产产品结束之后，马上通知消费者消费
消费者：没有消费之前通知生产者等待，消费产品结束之后，通知生产者继续生产产品以供消费

其中使用了缓冲区，需要考虑下面两点

从缓冲区取出产品和向缓冲区投放产品必须是互斥进行的。可以用关键段和互斥量来完成。
生产者要等待缓冲区为空，这样才可以投放产品，消费者要等待缓冲区不为空，这样才可以取出产品进行消费。并且由于有二个等待过程，所以要用二个事件或信号量来控制。

两种发放实现生产者、消费者模式

看看下面例子：

生产者：往一个公共的盒子里面放苹果

消费者：从公共的盒子里面取苹果

盒子：盒子的容量不能超过5

方法一：wait() 和 notify() 通信方法实现

    Java代码   
    
  
 <span style="font-size: 14px;">        public class PublicBox {   
            private int apple = 0;       
            public synchronized void increace() {   
                while (apple ==5) {   
                    try {   
                        wait();   
                    } catch (InterruptedException e) {   
                        e.printStackTrace();   
                    }   
                     
                }   
                apple++;   
                System. out .println("生成苹果成功！" );  
                notify();   
            }         
            public synchronized void decreace() {   
                while (apple ==0) {   
                    try {   
                        wait();   
                    } catch (InterruptedException e) {   
                        e.printStackTrace();   
                    }   
                }   
                apple--;   
               System. out.println( "消费苹果成功！" );  
                notify();   
            }   
             
            public static void main(String []args)  
               {  
                      PublicBox box= new PublicBox();  
                        
                      Consumer con= new Consumer(box);  
                      Producer pro= new Producer(box);  
                        
                      Thread t1= new Thread(con);  
                      Thread t2= new Thread(pro);  
                        
                      t1.start();  
                      t2.start();  
                        
                        
               }  
        }</span>  

多个生产者和多个消费者

    Java代码   
    
  
 <span style="font-size: 14px;">生产者代码（定义十次）：  
   
 public class Producer implements Runnable {   
     private PublicBox box;   
    
     public Producer(PublicBox box) {   
         this .box = box;   
     }   
    
     @Override   
     public void run() {   
          
         for( int i=0;i<10;i++)    
        {  
                try {  
                      System. out .println("pro  i:" +i);  
                            Thread. sleep(30);  
                      } catch (InterruptedException e) {  
                             // TODO: handle exception  
                            e.printStackTrace();  
                      }  
          
             box.increace();   
        }  
           
     }   
 }  
   
 消费者代码（同样十次）：  
   
 public class Consumer implements Runnable {   
     private PublicBox box;   
    
     public Consumer(PublicBox box) {   
         this .box = box;   
     }   
    
     @Override   
     public void run() {   
          
         for( int i=0;i<10;i++)  
        {  
              try {  
                      System. out .println("Con: i " +i);  
                            Thread. sleep(3000);                // 这里设置跟上面30不同是为了 盒子中的苹果能够增加，不会生产一个马上被消费    
                      } catch (InterruptedException e) {  
                             // TODO: handle exception  
                            e.printStackTrace();  
                      }  
          
             box.decreace();   
         }   
  }   
 }</span>  

结果

pro i:0

Con: i 0

生成苹果成功！

pro i:1

生成苹果成功！

pro i:2

生成苹果成功！

pro i:3

生成苹果成功！

pro i:4

生成苹果成功！

pro i:5

消费苹果成功！

Con: i 1

生成苹果成功！

pro i:6

消费苹果成功！

Con: i 2

生成苹果成功！

pro i:7

消费苹果成功！

生成苹果成功！

pro i:8

Con: i 3

消费苹果成功！

生成苹果成功！

pro i:9

Con: i 4

消费苹果成功！

生成苹果成功！

Con: i 5

消费苹果成功！

Con: i 6

消费苹果成功！

Con: i 7

消费苹果成功！

Con: i 8

消费苹果成功！

Con: i 9

消费苹果成功！

方法二：阻塞队列实现生产者消费者模式

阻塞队列实现生产者消费者模式超级简单，它提供开箱即用支持阻塞的方法put()和take()，开发者不需要写困惑的wait-nofity代码去实现通信。BlockingQueue 一个接口，Java5提供了不同的现实，如ArrayBlockingQueue和LinkedBlockingQueue，两者都是先进先出（FIFO）顺序。而ArrayLinkedQueue是自然有界的，LinkedBlockingQueue可选的边界。下面这是一个完整的生产者消费者代码例子，对比传统的wait、nofity代码，它更易于理解。

盒子代码

    Java代码   
    
  
 <span style="font-size: 14px;">import java.util.concurrent.BlockingQueue;  
 import java.util.concurrent.LinkedBlockingQueue;  
   
 public class PublicBoxQueue {  
   
          
         public static void main(String []args)  
        {  
                BlockingQueue publicBoxQueue= new LinkedBlockingQueue(5);   //定义了一个大小为5的盒子  
                 
               Thread pro= new Thread(new ProducerQueue(publicBoxQueue));  
               Thread con= new Thread(new ConsumerQueue(publicBoxQueue));  
                 
               pro.start();  
               con.start();  
        }  
          
 }</span>  

生产者

    Java代码   
    
  
 <span style="font-size: 14px;">package dsd;  
   
 import java.util.concurrent.BlockingQueue;  
   
 public class ProducerQueue implements Runnable {  
   
         private final BlockingQueue proQueue;  
          
         public ProducerQueue(BlockingQueue proQueue)  
        {  
                this .proQueue =proQueue;  
        }  
   
         @Override  
         public void run() {  
                // TODO Auto-generated method stub  
                 
                for (int i=0;i<10;i++)  
               {  
                       try {  
                            System. out .println("生产者生产的苹果编号为 : " +i);  //放入十个苹果编号 为1到10  
                             proQueue .put(i);  
                              
                             /*Thread.sleep(3000);*/  
                      } catch (InterruptedException  e) {  
                             // TODO: handle exception  
                            e.printStackTrace();  
                      }  
                        
               }  
                 
        }  
          
          
 }</span>  

消费者

    Java代码   
    
  
 <span style="font-size: 14px;">package dsd;  
   
 import java.util.concurrent.BlockingQueue;  
   
 public class ConsumerQueue implements Runnable {  
   
         private final BlockingQueue conQueue;  
          
         public ConsumerQueue(BlockingQueue conQueue)  
        {  
                this .conQueue =conQueue;  
        }  
   
         @Override  
         public void run() {  
                // TODO Auto-generated method stub  
                for (int i=0;i<10;i++)  
               {  
                       try {  
                            System. out .println("消费者消费的苹果编号为 ：" +conQueue .take());  
                            Thread. sleep(3000);  //在这里sleep是为了看的更加清楚些  
                              
                      } catch (InterruptedException e) {  
                             // TODO: handle exception  
                            e.printStackTrace();  
                      }  
               }  
        }  
          
          
 }</span>  

结果

生产者生产的苹果编号为 : 0

生产者生产的苹果编号为 : 1

消费者消费的苹果编号为：0

生产者生产的苹果编号为 : 2

生产者生产的苹果编号为 : 3

生产者生产的苹果编号为 : 4

生产者生产的苹果编号为 : 5

生产者生产的苹果编号为 : 6

生产者生产的苹果编号为 : 7

消费者消费的苹果编号为：1

消费者消费的苹果编号为：2

生产者生产的苹果编号为 : 8

消费者消费的苹果编号为：3

生产者生产的苹果编号为 : 9

消费者消费的苹果编号为：4

消费者消费的苹果编号为：5

消费者消费的苹果编号为：6

消费者消费的苹果编号为：7

消费者消费的苹果编号为：8

消费者消费的苹果编号为：9

生产者消费者模式优点

解耦：分开生产者和消费者的依赖，耦合度低。
支持并发：生产者和消费者是两个独立的并发体，他们通过缓冲区作为桥梁，生产者只需要往缓冲区里丢数据，就可以生产下一个数据，消费者只需要在缓冲区中取数据，这样两个并发体都不会因为出来速度而引起阻塞。
支持忙闲不均：如果生产者时快时慢，缓冲区的好处就好大，当生产者速度很快，任务就会在缓冲区缓存起来，让消费者依次去执行；当生产者速度比较慢，消费者可以从缓冲区中取任务，消费者不需要等到生产了任务才有工作，除非缓冲区为空。

应用场景