生产者消费者

生产一个消费一个

// import java.util.concurrent.locks.Condition;
// import java.util.concurrent.locks.Lock;
// import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.*;
// 生产一个消费一个
class ProducerConsumer {
    private int number = 0; // 产品数量
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void produce() throws Exception {
        lock.lock();
        try { 
            while (number != 0) {
                // could not produce
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "+1");
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void consume() throws Exception {
        lock.lock();
        try {
            while (number == 0) {
                // could not consume
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "-1");
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                     pc.produce();
                } catch (Exception e) {
                    e.printStackTrace();
                }
               
            }, "producer").start();
        }

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    pc.consume();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                
            }, "consumer").start();
        }

    }
}

buffersize

// import java.util.concurrent.locks.Condition;
// import java.util.concurrent.locks.Lock;
// import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.*;
// 生产数量不能超过buffersize
class ProducerConsumer2 {
    private int number = 0; // 产品数量
    private int size = 3; // buffersize
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public void produce() throws Exception {
        lock.lock();
        try { 
            while (number == size) {
                // could not produce
                notFull.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "+1" + " curNum: " + number);
            notEmpty.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void consume() throws Exception {
        lock.lock();
        try {
            while (number == 0) {
                // could not consume
                notEmpty.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "-1" + " curNum: " + number);
            notFull.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ProducerConsumer2 pc = new ProducerConsumer2();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                     pc.produce();
                } catch (Exception e) {
                    e.printStackTrace();
                }
               
            }, "producer").start();
        }

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    pc.consume();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                
            }, "consumer").start();
        }

    }
}