java利用多线程实现生产者和消费者功能————美的掉渣的代码

1.使用wait()/notifyAll实现生产者和消费者

/**
 * 锁对象类
 * 协作类
 */
public class MyQueue {
    private Queue<Integer> queue;
    private int limit;

    public MyQueue(int limit) {
        this.queue = new ArrayDeque<>(limit);
        this.limit = limit;
    }

    public synchronized void put(int n) throws InterruptedException {
        while (queue.size()==limit){
            wait();
        }
        queue.add(n);
        /**
         * 通知所有queue上的线程（消费者线程，生产者线程）
         */
        notifyAll();
    }
    public synchronized int get() throws InterruptedException {
        while (queue.isEmpty()){
            wait();
        }
        int e=queue.poll();
        /**
         * 通知所有queue上的线程（消费者线程，生产者线程）
         */
        notifyAll();
        return e;
    }
}

/**
 * 生产者线程
 */
public class ProduceThread extends Thread {
    private MyQueue queue;

    public ProduceThread(MyQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        int num=0;
        while (true){
            try {
                System.out.println("生产数据：" + num);
                queue.put(num);
                num++;
                Thread.sleep((int)(Math.random()*100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 消费者线程
 */
public class ConsumerThread extends Thread {
    private MyQueue queue;

    public ConsumerThread(MyQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
       while (true){
           try {
               int res=queue.get();
               System.out.println("消费数据："+res);
               Thread.sleep((int)(Math.random()*100));
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }
}

/**
 * 主线程
 */
public class MainTest {
    public static void main(String[] args) {
        MyQueue queue=new MyQueue(100);
        new ProduceThread(queue).start();
        new ConsumerThread(queue).start();
    }
}

2.使用ReentrantLock和condition实现生产者和消费者功能

/**
 * 协作类
 */
public class MyBlockQueue {
    private Queue<Integer> queue=null;
    private int limit;
    private Lock lock=new ReentrantLock();
    private Condition produceCondition =lock.newCondition();
    private Condition ConsumerCondition =lock.newCondition();

    public MyBlockQueue(int limit) {
        this.limit = limit;
        queue=new ArrayDeque<>(limit);
    }
    public void put(int n) throws InterruptedException {
        lock.lockInterruptibly();//可中断锁
        try {
            while (queue.size()==limit){
                produceCondition.await();
            }
            queue.add(n);
            ConsumerCondition.signal();
        }finally {
            lock.unlock();
        }
    }


    public int get() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            while (queue.isEmpty()){
                ConsumerCondition.await();
            }
            int e=queue.poll();
            produceCondition.signal();
            return  e;
        }finally {
            lock.unlock();
        }
    }
}

/**
 * 生产者线程
 */
public class ProduceThread extends Thread {
    private MyBlockQueue queue;

    public ProduceThread(MyBlockQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        int num=0;
        while (true){
            try {
                System.out.println("生产数据：" + num);
                queue.put(num);
                num++;
                Thread.sleep((int)(Math.random()*100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 消费者线程
 */
public class ConsumerThread extends Thread {
    private MyBlockQueue queue;

    public ConsumerThread(MyBlockQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
       while (true){
           try {
               int res=queue.get();
               System.out.println("消费数据："+res);
               Thread.sleep((int)(Math.random()*100));
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }
}

/**
 * 主线程
 */
public class MainTest {
    public static void main(String[] args) {
        MyBlockQueue queue=new MyBlockQueue(100);
        new ProduceThread(queue).start();
        new ConsumerThread(queue).start();
    }
}

分析：wait/notify只能实现一个条件队列；准备唤醒生产者队列，却把消费者也唤醒了；相互竞争后最终生产者满足条件，开始执行，消费者再次变成等待状态。

而使用显示锁，则可以创建多条等待队列。