Art of Multiprocessor Programming 答案 ch8 p93

public interface Lock {

    void lock();
    void unlock();
}

public interface ReadWriteLock {

    Lock readLock();
    Lock writeLock();
}

public class SimpleReadWriteLock implements ReadWriteLock {

    private int readers;
    private boolean writer;

    private Lock readLock;
    private Lock writeLock;

    private final Object lockObj;

    public SimpleReadWriteLock() {
        readers = 0;
        writer = false;
        lockObj = new Object();
        readLock = new ReadLock();
        writeLock = new WriteLock();
    }

    @Override
    public Lock readLock() {
        return readLock;
    }

    @Override
    public Lock writeLock() {
        return writeLock;
    }

    private class ReadLock implements Lock {

        @Override
        public void lock() {
            try {
                synchronized (lockObj) {
                    while (writer) {
                        lockObj.wait();//有线程持有写锁，其他线程不能获得读锁
                    }
                    ++readers;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void unlock() {
            synchronized (lockObj) {
                --readers;
                if (readers == 0) {
                    lockObj.notifyAll();//没有线程持有读锁，唤醒等待的写线程
                }
            }
        }
    }

    private class WriteLock implements Lock {

        @Override
        public void lock() {
            try {
                synchronized (lockObj) {
                    while (readers > 0 || writer) {
                        lockObj.wait();//有线程持有读锁或者写锁,其他线程不能获得写锁
                    }
                    writer = true;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

        @Override
        public void unlock() {
            synchronized (lockObj) {
                writer = false;
                lockObj.notifyAll();//释放写锁，唤醒等待中的读线程或者写线程
            }
        }
    }

}

public class SimpleReadWriteLock implements ReadWriteLock {

    private int readers;
    private boolean writer;

    private Lock readLock;
    private Lock writeLock;

    private final Object lockObj;

    public SimpleReadWriteLock() {
        readers = 0;
        writer = false;
        lockObj = new Object();
        readLock = new ReadLock();
        writeLock = new WriteLock();
    }

    @Override
    public Lock readLock() {
        return readLock;
    }

    @Override
    public Lock writeLock() {
        return writeLock;
    }

    private synchronized void read_lock() {
        try {
            while (writer) {
                wait();//有线程持有写锁，其他线程不能获得读锁
            }
            ++readers;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private synchronized void read_unlock() {
        --readers;
        if (readers == 0) {
            notifyAll();//没有线程持有读锁，唤醒等待的写线程
        }
    }

    private synchronized void write_lock() {
        try {
            while (readers > 0 || writer) {
                wait();//有线程持有读锁或者写锁,其他线程不能获得写锁
            }
            writer = true;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private synchronized void write_unlock(){
        writer = false;
        notifyAll();//释放写锁，唤醒等待中的读线程或者写线程
    }

    private class ReadLock implements Lock {

        @Override
        public void lock() {
            read_lock();
        }

        @Override
        public void unlock() {
            read_unlock();
        }
    }

    private class WriteLock implements Lock {

        @Override
        public void lock() {
            write_lock();
        }

        @Override
        public void unlock() {
            write_unlock();
        }
    }

}

测试示例：

public class TestSRWLock {

    private int value = 0;

    private Lock readLock;
    private Lock writeLock;

    public TestSRWLock() {
        SimpleReadWriteLock srwLock = new SimpleReadWriteLock();
        readLock = srwLock.readLock();
        writeLock = srwLock.writeLock();
    }

    public void test() {
        Thread read1 = new ReadThread();
        Thread read2 = new ReadThread();
        Thread write1 = new WriteThread();
        Thread write2 = new WriteThread();
        write1.start();
        read1.start();
        write2.start();
        read2.start();
    }

    public void read() {
        readLock.lock();
        try {
            System.out.println("Thread: " + Thread.currentThread().getName() + " getReadLock");
            System.out.println("value = " + value);
        } finally {
            readLock.unlock();
        }
    }

    public void write() {
        writeLock.lock();
        try {
            System.out.println("Thread: " + Thread.currentThread().getName() + " getWriteLock");
            ++value;
            System.out.println("value = " + value);
        } finally {
            writeLock.unlock();
        }
    }

    private class ReadThread extends Thread {

        @Override
        public void run() {
            read();
        }
    }

    private class WriteThread extends Thread {

        @Override
        public void run() {
            write();
        }
    }
}

测试结果：

Thread: Thread-2 getWriteLock
value = 1
Thread: Thread-0 getReadLock
value = 1
Thread: Thread-3 getWriteLock
value = 2
Thread: Thread-1 getReadLock
value = 2

Thread: Thread-2 getWriteLock
value = 1
Thread: Thread-0 getReadLock
value = 1
Thread: Thread-1 getReadLock
value = 1
Thread: Thread-3 getWriteLock
value = 2