ReentrantLock 实现 多生产者和多消费者（读写）

package com.ct.collection;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {
    private static AtomicInteger count = new AtomicInteger();
    private static ReentrantLock write = new ReentrantLock();
    private static ReentrantLock read = new ReentrantLock();
    private static Condition condition = read.newCondition();
    private static Condition writeCondition = write.newCondition();
    //控制每次读写线程操纵数字范围
    private static volatile int capacity = 2;

    static class read implements Runnable {
        @Override
        public void run() {

            try {
                read.lock();
                while (count.get() == 0) {
                    signalWrite();
                }

                Thread.sleep(2000);
                System.out.println("read " + count.getAndDecrement());

            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                read.unlock();
            }
        }

        private static void signalWrite() {
            final ReentrantLock putLock = write;
            putLock.lock();
            try {
                writeCondition.signal();
            } finally {
                putLock.unlock();
            }
        }
    }

    static class write implements Runnable {

        @Override
        public void run() {
            try {
                write.lock();

                while (count.get() == capacity) {
                    writeCondition.await();
                }

                System.out.println("write " + count.incrementAndGet());
                Thread.sleep(1000);

                if (count.get() > capacity)
                    signalRead();

            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                write.unlock();
            }

        }
    }

    private static void signalRead() {
        final ReentrantLock takeLock = read;
        takeLock.lock();
        try {
            condition.signal();
        } finally {
            takeLock.unlock();
        }
    }

}

package com.ct.collection;

import java.util.concurrent.*;

public class Main {

        public static void main(String[] args) {
            //控制线程数量
            int capacity = 10;
            ExecutorService service = Executors.newFixedThreadPool(capacity);
            for(int i=0;i<capacity ;i++){
                service.execute(new ReentrantLockDemo.read());
                service.execute(new ReentrantLockDemo.write());
            }
            service.shutdown();
        }


}