Java - 生产者消费者

需求： 一个初始值为0，一个加一，一个减1，循环操作

基于Lock的生产者消费者模型

class SharaData {
    private AtomicInteger number = new AtomicInteger();
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void increment() {
        lock.lock();
        try {
            while (number.get() != 0) {
                condition.await();
            }
            number.incrementAndGet();
            System.out.println(Thread.currentThread().getName() + "生产：  " + number.get());
            condition.signalAll();
        }catch(Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void decrement() {
        lock.lock();
        try {
            while (number.get() == 0) {
                condition.await();
            }
            Thread.sleep(1000);
            number.decrementAndGet();
            System.out.println(Thread.currentThread().getName() + "消费：  " + number.get());
            condition.signalAll();
        }catch(Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
public class ProduceAndConsumerDemo {
    public static void main(String[] args) {
        SharaData data = new SharaData();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                data.increment();
            }
        },"A").start();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                data.decrement();
            }
        }, "b").start();
    }
}

基于阻塞队列的生产消费者模型

public class ProducerConsumerWithBlocking {
    private AtomicInteger number = new AtomicInteger();
    private BlockingQueue<String> queue = null;
    private volatile boolean FLAG = true;

    public ProducerConsumerWithBlocking(BlockingQueue<String> queue) {
        this.queue = queue;
        System.out.println(queue.getClass().getName());
    }

    public void increment() throws InterruptedException {
        String data = null;
        boolean retValue;
        while (FLAG) {
            data = number.incrementAndGet() + "";
            retValue = queue.offer(data, 2L, TimeUnit.SECONDS);
            if (retValue) {
                System.out.println(Thread.currentThread().getName() + "插入队列:" + data + "成功");
            } else {
                System.out.println(Thread.currentThread().getName() + "插入队列:" + data + "失败");
            }
            TimeUnit.SECONDS.sleep(1);
        }
        System.out.println("生产停止");
    }

    public void decrement() throws InterruptedException {
        String result = null;
        while (FLAG) {
            result = queue.poll(2L, TimeUnit.SECONDS);
            if (null == result || result.equalsIgnoreCase("")) {
                FLAG = false;
                System.out.println("超过两秒钟没有数据，消费退出");
                return;
            }
            System.out.println(Thread.currentThread().getName() + "消费队列成功：" + result);
        }
    }
    public void stop()
    {
        FLAG = false;
    }

    public static void main(String[] args) {
        ProducerConsumerWithBlocking demo = new ProducerConsumerWithBlocking(new SynchronousQueue<>());
        new Thread(() -> {
            try {
                demo.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        new Thread(() -> {
            try {
                demo.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "B").start();
    }
}