个人学习笔记：java多线程生产者消费者问题两种不同简单实现

问题描述：写一个固定容量同步容器，拥有put和get方法，能够支持2个生产者线程以及8个消费者线程的阻塞调用。

1、实现方式一：

使用Synchronized关键字和wait以及notifyAll方法实现。需注意！强烈建议，wait方法与while搭配使用而不是if，唤醒等待线程使用notifyAll而不是notify。（一些好的编程习惯详见effective java）

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;


public class Test1<T> {
    //创建容器
    List<T> container=new LinkedList<T>();
    private int maxSize=10;//设置容器最大容量

    /**
     * 生产者线程向容器中添加一个产品
     * @param element
     */
    public synchronized void set(T element){
        //容器满了，阻塞
        while (container.size()==maxSize){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        container.add(element);//将产品放入容器中
        this.notifyAll();
    }
    /**
     * 消费者线程消费容器中的一个产品
     * @return
     */
    public synchronized T get(){
        //容器空了，阻塞，等待生产者线程生产
        while (container.size()==0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //从容器中删除元素
        T element=container.remove(0);
        this.notifyAll();
        return element;
    }


    public static void main(String[] args) {

        Test1<String> test1=new Test1<>();

        //启动生产者线程
        for (int i = 0; i <2; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j <20; j++) {
                        test1.set(Thread.currentThread().getName()+"-"+j);
                    }
                }
            },"producer "+i).start();
        }

        //启动消费者线程
        for (int i = 0; i <8; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j <5; j++) {
                        System.out.println(Thread.currentThread().getName()+"-"+j+"-"+test1.get());
                    }
                }
            },"consumer "+i).start();
        }

        try {
            //主线程睡眠1秒，等待其他线程执行完成
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

2、实现方式二：

使用Lock和Condition来实现，Condition的方式可以更加精确的指定哪些线程被唤醒，指定唤醒消费者线程或生产者线程，而不像notifyAll将所有线程都唤醒。同样，强烈建议await方法应与while语句联合使用，而不是与if语句联合使用。

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test2<T> {
    //创建容器
    List<T> container=new LinkedList<T>();
    private int maxSize=10;//设置容器最大容量
    private Lock lock=new ReentrantLock();
    //
    private Condition producer=lock.newCondition();
    //
    private Condition consumer=lock.newCondition();
    /**
     * 生产者线程向容器中添加一个产品
     * @param element
     */
    public  void set(T element){
        try {
            lock.lock();
            //容器满了，阻塞，等待消费者线程消费
            while(container.size()==maxSize) {
                //生产者线程等待
                producer.await();
            }
            container.add(element);//将产品放入容器中
            //通知消费者线程进行消费
            consumer.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //一定不要忘记手动释放锁，避免造成死锁
            lock.lock();
        }

    }

    /**
     * 消费者线程消费容器中的一个产品
     * @return
     */
    public synchronized T get(){
        T element=null;
        try {
            lock.lock();
            //容器空了，阻塞，等待生产者线程生产
            while(container.size()==0){
                //消费者线程等待
                consumer.await();
            }
            //从容器中删除元素
            element=container.remove(0);
            //唤醒生产者线程进行生产
            producer.signalAll();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //一定不要忘记手动释放锁，避免造成死锁
            lock.lock();
        }
        return element;
    }


    public static void main(String[] args) {

        Test1<String> test1=new Test1<>();

        //启动生产者线程
        for (int i = 0; i <2; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j <20; j++) {
                        test1.set(Thread.currentThread().getName()+"-"+j);
                    }
                }
            },"producer "+i).start();
        }

        //启动消费者线程
        for (int i = 0; i <8; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j <5; j++) {
                        System.out.println(Thread.currentThread().getName()+"-"+j+"-"+test1.get());
                    }
                }
            },"consumer "+i).start();
        }

        try {
            //主线程睡眠1秒，等待其他线程执行完成
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}