读写锁 ReentrantReadWriteLock(共享锁+排他锁)

        重入锁ReentrantLock具有完全互斥排他的效果，即在同一时间，只有获取锁的线程才能够执行相应的操作，这样保证了线程安全，但是某些情况下也造成了效率低下的问题，比如被锁的代码块中只有读操作，不会修改任何变量，这样的话就会效率较低，那么我们可以使用JDK提供的另一种读写锁ReentrantReadWriteLock。

        ReentrantReadWriteLock包含两种锁，一个是读操作相关的共享锁，一个是写操作相关的排他锁。

•         多个共享锁之间不互斥，多个排他锁之间互斥，共享锁与排他锁互斥。
•         当没有线程进行写操作的时候，多个进行读操作的线程都可以获取读锁；
•         进入写操作的线程只有在获取写锁时才能进行写操作，并且在同一时间只能有一个线程进行写操作;
•         当写操作线程获取锁后，不管是读操作还是写操作后要等写操作线程释放锁后才能继续进行。
•         当读操作线程获取读锁后，写操作同样要等读操作线程释放锁后才能继续进行。

        

        代码测试

        读读共享，写写互斥

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读读共享,写写互斥
 */
public class ReentrantReadWriteLockTest1 {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void testMethod(){

        try{
            lock.readLock().lock(); //读读共享
//            lock.writeLock().lock(); //写写互斥
            for(int i = 0; i < 6; i++){
                System.out.println("Thread---" + Thread.currentThread().getName() + "--读锁读取信息中……");
                Thread.sleep(1000);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        } finally {
            lock.readLock().unlock(); //读读共享
//            lock.writeLock().unlock(); //写写互斥
        }
    }

    public static void main(String[] args){

        ReentrantReadWriteLockTest1 test1 = new ReentrantReadWriteLockTest1();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                test1.testMethod();
            }
        };

        Thread threadA = new Thread(runnable);
        Thread threadB = new Thread(runnable);
        threadA.setName("A");
        threadB.setName("B");
        threadA.start();
        threadB.start();
    }
}

运行结果，使用读锁(共享锁)多个线程可以同时执行锁定的代码块。

将代码中的写锁注释去掉，同时注释掉读锁

运行结果，使用写锁(排他锁)多个线程只能有一个线程在同一时间执行锁定的代码块。

        读写互斥，写读互斥

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写互斥，写读互斥.
 */
public class ReentrantReadWriteLockTest2 {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void testRead(){
        try{
            lock.readLock().lock();
            for(int i = 0; i < 6; i++){
                System.out.println("Thread---" + Thread.currentThread().getName() + "--读锁读取信息中……");
                Thread.sleep(1000);
            }
        } catch(InterruptedException e){
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

    public void testWrite(){
        try{
            lock.writeLock().lock();
            for(int i = 0; i < 6; i++){
                System.out.println("Thread---" + Thread.currentThread().getName() + "--写锁写操作中……");
                Thread.sleep(1000);
            }
        } catch(InterruptedException e){
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }

    public static void main(String[] args){

        ReentrantReadWriteLockTest2 test2 = new ReentrantReadWriteLockTest2();

        Runnable runnableRead = new Runnable() {
            @Override
            public void run() {
                test2.testRead();
            }
        };

        Runnable runnableWrite = new Runnable() {
            @Override
            public void run() {
                test2.testWrite();
            }
        };

        Thread threadA = new Thread(runnableRead);
        Thread threadB = new Thread(runnableWrite);
        threadA.setName("A");
        threadB.setName("B");
        threadA.start();
        threadB.start();

    }
}

运行结果