ReentrantReadWriteLock的相关使用

ReentrantLock具有完全互斥排他的效果，同一时间只有一个线程执行ReentrantLock.lock()方法后面的任务，这样虽然能够保证线程安全性，但是效率是比较低的

ReentrantReadWriteLock可以加快运行效率

ReentrantReadWriteLock读写锁有两个锁，读锁和写锁，读锁是共享锁，写锁是排他锁：

• 读锁与读锁不互斥
• 写锁与写锁互斥
• 读锁与写锁互斥
• 写锁与读锁互斥

ReentrantReadWriteLock

读锁与读锁不互斥

public class Test01 {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read(){
        try {
            lock.readLock().lock();
            System.out.println("获取读锁"+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

    public static void main(String[] args) {
        Test01 test = new Test01();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                test.read();
            }
        };
        Thread a = new Thread(runnable);
        a.setName("A");
        Thread b = new Thread(runnable);
        b.setName("B");
        a.start();
        b.start();
    }
}

-------------------------------------------------console-------------------------------------------------

获取读锁A 1539155032025
获取读锁B 1539155032025

打印结果显示线程A，B同时读取锁，证明多个线程获得读锁是不互斥的，使用读锁可以提高程序运行效率

写锁与写锁互斥

public class Test02 {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void write(){
        try {
            lock.writeLock().lock();
            System.out.println("获取写锁"+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }

    public static void main(String[] args) {
        Test02 test = new Test02();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                test.write();
            }
        };
        Thread a = new Thread(runnable);
        a.setName("A");
        Thread b = new Thread(runnable);
        b.setName("B");
        a.start();
        b.start();
    }
}

-------------------------------------------------console-------------------------------------------------

获取写锁A 1539155285755
获取写锁B 1539155295757

证明同一时间只允许一个线程执行lock()方法后面的代码

读锁与写锁互斥，写锁与读锁互斥

public class Test03 {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read(){
        try {

            lock.readLock().lock();
            System.out.println("获取读锁"+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

    public void write(){
        try {
            lock.writeLock().lock();
            System.out.println("获取写锁"+Thread.currentThread().getName()+" "+System.currentTimeMillis());
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }

    public static void main(String[] args) {
        Test03 test = new Test03();

        Thread a = new Thread(new Runnable() {
            @Override
            public void run() {
                test.read();
            }
        });
        a.setName("A");
        Thread b = new Thread(new Runnable() {
            @Override
            public void run() {
                test.write();
            }
        });
        b.setName("B");
        a.start();
        b.start();
    }
}

-------------------------------------------------console-------------------------------------------------

获取读锁A 1539155559525
获取写锁B 1539155569525

证明读写操作是互斥的，只要出现写操作的过程就是互斥的