java多线程：生产者消费者实现的几种方式

1.方式一：使用BlockingQueue

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by zs on 2019/8/19.
 */

public class MySampleProduceAndConsumer {
   
    BlockingQueue<Task> queue;

    AtomicInteger taskNo = new AtomicInteger(0);

    public MySampleProduceAndConsumer(int val){
   
        queue = new LinkedBlockingQueue<>(val);
    }
    public Runnable getConsumer(){
   
        return new Consumer();
    }
    public Runnable getProducer(){
   
        return new Producer();
    }

    class Consumer implements Runnable{
   
        @Override
        public void run(){
   
            //consume
            try {
   
                for (int i = 0; i < 50; i++) {
   
                    Task task = queue.take(); //关键代码1
                    System.out.println("cosume "+task.no);
                    Thread.sleep(5000);
                }
            }catch (InterruptedException e){
   
                e.printStackTrace();
            }


        }
    }
    class Producer implements Runnable{
   
        @Override
        public void run() {
   
            //produce
            try {
   
                for (int i = 0; i < 50; i++) {
   
                    Thread.sleep((long)(1000*Math.random()));
                    Task task = new Task(taskNo.getAndIncrement());
                    queue.put(task);                                //关键代码2
                    System.out.println("produce " + task.no);
                }
            }catch (InterruptedException e){
   
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args){
   
        MySampleProduceAndConsumer mb = new MySampleProduceAndConsumer(3);
        new Thread(mb.getConsumer()).start();
        new Thread(mb.getProducer()).start();
    }
}

需要注意：

//入队
queue.add(task); // 入队的时候，如果队列已满，则抛出异常

queue.offer(task);// 如果队列已满，则直接丢弃，还会不停生产，直到消费者消费一个，挪出一个空位置，才会添加进来，其余的全部丢弃了。

queue.put(task);// 入队的时候，如果队列已满，则阻塞，直到消费一个，添加进来，继续生产，继续阻塞。
//出队
Task task = queue.take();//如果队列为空，则一直阻塞

Task task = queue.remove();//删除成功返回true，否则返回false

Task task = queue.poll();//如果队列为空，返回NULL，否则返回元素

2.wait &&notify 实现

如果不能直接只有阻塞队列，不能将并发与容量控制都封装在缓冲区中，就只能由消费者生产者内部完成，最简单的方法就是使用朴素的wait&&notify实现线程同步。

import java.util.LinkedList;
import java.util.Queue;
import java