Java中生产者消费者问题总结

生产者-消费者算是并发编程中常见的问题。依靠缓冲区我们可以实现生产者与消费者之间的解耦。生产者只管往缓冲区里面放东西，消费者只管往缓冲区里面拿东西。这样我们避免生产者想要交付数据给消费者，但消费者此时还无法接受数据这样的情况发生。

wait notify

这个问题其实就是线程间的通讯，所以要注意的是不能同时读写。生产者在缓冲区满的时候不生产，等待；消费者在缓冲区为空的时候不消费，等待。比较经典的做法是wait和notify。

生产者线程执行15次set操作

public class producer implements runnable{
 private channel channel;

 public producer(channel channel) {
  this.channel = channel;
 }

 @override
 public void run() {
  for(int i=0;i<15;i++){
   channel.set(thread.currentthread().getname()+" "+i);
  }
 }
}

消费者线程执行10次get操作

public class consumer implements runnable {
 private channel channel;

 public consumer(channel channel) {
  this.channel = channel;
 }

 @override
 public void run() {
  for(int i=0;i<10;i++){
   system.out.println("consumer "+thread.currentthread().getname()+" get "+channel.get());
  }
 }
}

现在定义channel类,并创建两个生产者线程和三个消费者线程

public class channel {
 private list<string> buffer=new arraylist<>();
 private final int max_size=10;

 public synchronized string get(){
  while (buffer.size()==0){//不要用if，醒来了也要再次判断
   try {
    wait();
   } catch (interruptedexception e) {
    e.printstacktrace();
   }
  }
  string str=buffer.remove(0);
  notifyall();
  return str;
 }
 public synchronized void set(string str){
  while (buffer.size()==max_size){
   try {
    wait();
   } catch (interruptedexception e) {
    e.printstacktrace();
   }
  }
  buffer.add(str);
  notifyall();
 }

 public static void main(string[] args) {
  channel channel=new channel();
  producer producer=new producer(channel);
  consumer consumer=new consumer(channel);
  for(int i=0;i<2;i++){
   new thread(producer).start();
  }
  for (int i=0;i<3;i++){
   new thread(consumer).start();
  }
 }
}

使用notifyall而不是notify的原因是，notify有可能出现多次唤醒同类的情况，造成“假死”。我们可以使用condition来实现更精确的唤醒。

condition

将上面代码中的channel类修改一下即可

public class channel {
 private list<string> buffer=new arraylist<>();
 private final int max_size=10;
 private lock lock=new reentrantlock();
 private condition producer=lock.newcondition();
 private condition consumer=lock.newcondition();
 
 public string get(){
  string str=null;
  try {
   lock.lock();
   while (buffer.size()==0){
    consumer.await();
   }
   str=buffer.remove(0);
   producer.signalall();
  }catch (interruptedexception e) {
   e.printstacktrace();
  }finally {
   lock.unlock();
  }
  return str;
 }
 public void set(string str){
  try {
   lock.lock();
   while (buffer.size()==max_size){
    producer.await(); 
   }
   buffer.add(str);
   consumer.signalall();
  }catch (interruptedexception e) {
   e.printstacktrace();
  }finally {
   lock.unlock();
  }
 }
}

双缓冲与exchanger

当同步的花销非常大时，我们可以采用双缓冲区的办法。双缓冲的一个好处就在于：因为生产者和消费者各自拥有一个缓冲区，所以他们不会同时对同一个缓冲区进行操作，那么我们就不需要为读写操作加锁，用空间换了时间。在java中可以通过exchanger来交换两个线程之间的数据结构。

public class producer implements runnable{
 private list<string> buffer;
 private exchanger<list<string>> exchanger;
 public producer(list<string> buffer, exchanger<list<string>> exchanger){
  this.buffer=buffer;
  this.exchanger=exchanger;
 }
 @override
 public void run() {
  for(int i=0;i<10;i++){
   for (int j=0;j<10;j++)
   buffer.add("thrad "+thread.currentthread().getname()+" : "+i+" "+j);
   try {
    buffer=exchanger.exchange(buffer);
   } catch (interruptedexception e) {
    e.printstacktrace();
   }
  }

 }
}

public class consumer implements runnable {
 private exchanger<list<string>> exchanger;
 private list<string> buffer;

 public consumer(list<string> buffer,exchanger<list<string>> exchanger) {
  this.exchanger = exchanger;
  this.buffer = buffer;
 }

 @override
 public void run() {
  for(int i=0;i<10;i++){
   try {
    buffer=exchanger.exchange(buffer);
   } catch (interruptedexception e) {
    e.printstacktrace();
   }
   for(int j=0;j<10;j++){
    string message=buffer.get(0);
    system.out.println(message);
    buffer.remove(0);
   }
  }
 }
}

public class main {
 public static void main(string[] args) {
  list<string> buffer1=new arraylist<>();
  list<string> buffer2=new arraylist<>();
  exchanger<list<string>> exchanger=new exchanger<>();
  producer producer=new producer(buffer1,exchanger);
  consumer consumer=new consumer(buffer2,exchanger);
  thread t1=new thread(producer);
  thread t2=new thread(consumer);
  t1.start();
  t2.start();
 }
}

blockingqueue

我们可以使用更为方便安全的阻塞式集合来实现生产消费者模型。

这类集合具有的特点是：当集合已满或者是为空的时候，被调用的方法不会立即执行，该方法将被阻塞，直到可以成功执行为止。

public class channel {
 private blockingqueue<string> blockingqueue=new arrayblockingqueue<>(10);
 public string get(){
  string str=null;
  try {
   str=blockingqueue.take();
  } catch (interruptedexception e) {
   e.printstacktrace();
  }
  return str;
 }
 public void set(string str){
  try {
   blockingqueue.put(str);
  } catch (interruptedexception e) {
   e.printstacktrace();
  }
 }
}

这次的channel类是不是比之前的简洁了许多，有了blockingqueue我们就不用再去写wait和notify了。

到此这篇关于java中生产者消费者问题总结的文章就介绍到这了,更多相关java生产者消费者内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！