concurrent-02(实现生产者消费者模型)

生产者消费者问题是多线程中较经典的问题，使用synchronized方式实现如下：

public class SyncImpl <T>{

    private LinkedList<T> lists = new LinkedList<>();
    //当前容量
    private int cnt = 0;
    //设定最大容量为10
    private static final int MAX = 10;

    public int getCount(){
        return cnt;
    }

    //get方法上锁，解决多个消费者消费时某个产品被多次消费的问题
    private synchronized T get(){
        T element = null;
        //使用while而不是if，因为wait的程序被notify后会继续往下执行，且wait会释放锁
        while(lists.size() == 0){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        element = lists.removeFirst();
        cnt --;
        //使用notifyAll而不是notify，因为使用notify可能会唤醒另一个消费者导致程序无法继续运行
        notifyAll();

        return element;
    }

    //put方法上锁，解决多个生产者生产时超出最大容量的问题
    private synchronized void put(T t){
        //使用while而不是if，因为wait的程序被notify后会继续往下执行，且wait会释放锁
        while(lists.size() == MAX){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        lists.add(t);
        cnt ++;
        //使用notifyAll而不是notify，因为使用notify可能会唤醒另一个生产者导致程序无法继续运行
        notifyAll();
    }


    public static void main(String[] args) {
        SyncImpl<String> syncImpl = new SyncImpl<>();

        for(int i=0;i<10;i++){
            new Thread(()->{
                for(int j=0;j<10;j++){
                    System.out.println(syncImpl.get());
                }
            },"Consumer" + i).start();
        }

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for(int i=0;i<2;i++){
            new Thread(()->{
                for(int j=0;j<50;j++){
                    syncImpl.put(Thread.currentThread().getName());
                }
            },"Producer" + i).start();
        }
    }
}

使用ReentrantLock和Condition实现如下：

public class ConditionImpl<T> {
    private LinkedList<T> lists = new LinkedList<>();
    //当前容量
    private int cnt = 0;
    //最大容量
    private static final int MAX = 10;

    //重入锁，使用类而不是sync关键字，所以更灵活，可以tyrLock，但需要手动释放锁
    private Lock lock = new ReentrantLock();

    //生产者condition，用于生产者的等待和唤醒
    private Condition producer = lock.newCondition();
    //消费者condition，用于消费者的等待和唤醒
    private Condition consumer = lock.newCondition();

    public int getCount() {
        return cnt;
    }

    private T get() {
        //使用ReentrantLock上锁代替sync关键字
        lock.lock();
        try {
            T element = null;
            //使用while而不是if，因为await的程序被signal后会继续往下执行
            while (lists.size() == 0) {
                try {
                    //容器空了之后消费者开始等待
                    consumer.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            element = lists.removeFirst();
            cnt--;
            //通知生产者开始生产
            producer.signalAll();

            return element;
        } finally {
            //最后一定要手动释放锁
            lock.unlock();
        }
    }

    private void put(T t) {
        //使用ReentrantLock上锁代替sync关键字
        lock.lock();
        try {
            //使用while而不是if，因为await的程序被signal后会继续往下执行，await会释放锁
            while (lists.size() == MAX) {
                try {
                    //容器满了之后生产者开始等待
                    producer.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            lists.add(t);
            cnt++;
            //通知消费者开始消费
            consumer.signalAll();
        } finally {
            //最后一定要手动释放锁
            lock.unlock();
        }

    }

    public static void main(String[] args) {
        ConditionImpl<String> conditonImpl = new ConditionImpl<>();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10; j++) {
                    System.out.println(conditonImpl.get());
                }
            }, "Consumer: " + i).start();
        }

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 50; j++) {
                    conditonImpl.put(Thread.currentThread().getName());
                }
            }, "Producer: " + i).start();
        }
    }
}