ReadWriteLock读写锁的使用（Java并发）

今天药忘吃喽~ 2021-09-22 23:14 350阅读 0赞

## **微信搜索：“二十同学” 公众号，欢迎关注一条不一样的成长之路** ##

说到Java并发编程，很多开发第一个想到同时也是经常常用的肯定是Synchronized，但是Synchronized存在明显的一个性能问题就是读与读之间互斥，简言之就是，我们编程想要实现的最好效果是，可以做到读和读互不影响，读和写互斥，写和写互斥，提高读写的效率，如何实现呢？

Java并发包中ReadWriteLock是一个接口，主要有两个方法，如下：

public interface ReadWriteLock {
        /**
         * Returns the lock used for reading.
         *
         * @return the lock used for reading
         */
        Lock readLock();
    
        /**
         * Returns the lock used for writing.
         *
         * @return the lock used for writing
         */
        Lock writeLock();
    }

ReadWriteLock管理一组锁，一个是只读的锁，一个是写锁。  
Java并发库中ReetrantReadWriteLock实现了ReadWriteLock接口并添加了可重入的特性。  
在具体讲解ReetrantReadWriteLock的使用方法前，我们有必要先对其几个特性进行一些深入学习了解。

# 1. ReetrantReadWriteLock特性说明 #

## 1.1 获取锁顺序 ##

*  非公平模式（默认）  
    当以非公平初始化时，读锁和写锁的获取的顺序是不确定的。非公平锁主张竞争获取，可能会延缓一个或多个读或写线程，但是会比公平锁有更高的吞吐量。
 *  公平模式  
    当以公平模式初始化时，线程将会以队列的顺序获取锁。当当前线程释放锁后，等待时间最长的写锁线程就会被分配写锁；或者有一组读线程组等待时间比写线程长，那么这组读线程组将会被分配读锁。

## 1.2 可重入 ##

什么是可重入锁，不可重入锁呢？"重入"字面意思已经很明显了，就是可以重新进入。可重入锁，就是说一个线程在获取某个锁后，还可以继续获取该锁，即允许一个线程多次获取同一个锁。比如synchronized内置锁就是可重入的，如果A类有2个synchornized方法method1和method2，那么method1调用method2是允许的。显然重入锁给编程带来了极大的方便。假如内置锁不是可重入的，那么导致的问题是：1个类的synchornized方法不能调用本类其他synchornized方法，也不能调用父类中的synchornized方法。与内置锁对应，JDK提供的显示锁ReentrantLock也是可以重入的，这里通过一个例子着重说下可重入锁的释放需要的事儿。

import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class Test {
    
        public static void main(String[] args) throws InterruptedException {
            final ReentrantReadWriteLock  lock = new ReentrantReadWriteLock ();
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    lock.writeLock().lock();
                    System.out.println("Thread real execute");
                    lock.writeLock().unlock();
                }
            });
    
            lock.writeLock().lock();
            lock.writeLock().lock();
            t.start();
            Thread.sleep(200);
            
            System.out.println("realse one once");
            lock.writeLock().unlock();
        }
    
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70][]从运行结果中，可以看到，程序并未执行线程的run方法，由此我们可知，上面的代码会出现死锁，因为主线程2次获取了锁，但是却只释放1次锁，导致线程t永远也不能获取锁。**一个线程获取多少次锁，就必须释放多少次锁。这对于内置锁也是适用的，每一次进入和离开synchornized方法(代码块)，就是一次完整的锁获取和释放。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 1][]

## 1.3 锁降级 ##

要实现一个读写锁，需要考虑很多细节，其中之一就是锁升级和锁降级的问题。什么是升级和降级呢？ReadWriteLock的javadoc有一段话：

> Can the write lock be downgraded to a read lock without allowing an intervening writer? Can a read lock be upgraded to a write lock, in preference to other waiting readers or writers?

翻译过来的结果是：在不允许中间写入的情况下，写入锁可以降级为读锁吗？读锁是否可以升级为写锁，优先于其他等待的读取或写入操作？简言之就是说，锁降级：从写锁变成读锁；锁升级：从读锁变成写锁，ReadWriteLock是否支持呢？让我们带着疑问，进行一些Demo 测试代码验证。

### Test Code 1 ###

import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class Test {
    
        public static void main(String[] args) {
        	
        	 ReentrantReadWriteLock rtLock = new ReentrantReadWriteLock();
             rtLock.readLock().lock();
             System.out.println("get readLock.");
             rtLock.writeLock().lock();
             System.out.println("blocking");
            
        }
    
    }

### Test Code 1 Result ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 2][]

结论：上面的测试代码会产生死锁，因为同一个线程中，在没有释放读锁的情况下，就去申请写锁，这属于**锁升级，ReentrantReadWriteLock是不支持的**。

### Test Code 2 ###

import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class Test {
    
        public static void main(String[] args) {
        	
        	ReentrantReadWriteLock rtLock = new ReentrantReadWriteLock();  
            rtLock.writeLock().lock();  
            System.out.println("writeLock");  
              
            rtLock.readLock().lock();  
            System.out.println("get read lock");  
            
        }
    
    }

### Test Code 2 Result ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 3][]

结论：**ReentrantReadWriteLock支持锁降级**，上面代码不会产生死锁。这段代码虽然不会导致死锁，但没有正确的释放锁。从写锁降级成读锁，并不会自动释放当前线程获取的写锁，仍然需要显示的释放，否则别的线程永远也获取不到写锁。

# 2. ReetrantReadWriteLock对比使用 #

## 2.1 Synchronized实现 ##

在使用ReetrantReadWriteLock实现锁机制前，我们先看一下，多线程同时读取文件时，用synchronized实现的效果

/**
     * 
     * synchronized实现
     *
     */
    public class ReadAndWriteLockTest  {
    
    	public synchronized static void get(Thread thread) {
            System.out.println("start time:" + System.currentTimeMillis());
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(thread.getName() + ":正在进行读操作……");
            }
            System.out.println(thread.getName() + ":读操作完毕！");
            System.out.println("end time:" + System.currentTimeMillis());
        }
    
        public static void main(String[] args) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    get(Thread.currentThread());
                }
            }).start();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    get(Thread.currentThread());
                }
            }).start();
        }
    }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 4][]

**从运行结果可以看出，两个线程的读操作是顺序执行的，整个过程大概耗时200ms。**

## 2.2 ReetrantReadWriteLock实现 ##

import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /**
     * 
     * ReetrantReadWriteLock实现
     *
     */
    public class ReadAndWriteLockTest  {
    
    	public static void get(Thread thread) {
            ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
            lock.readLock().lock();
            System.out.println("start time:" + System.currentTimeMillis());
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(thread.getName() + ":正在进行读操作……");
            }
            System.out.println(thread.getName() + ":读操作完毕！");
            System.out.println("end time:" + System.currentTimeMillis());
            lock.readLock().unlock();
        }
    
        public static void main(String[] args) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    get(Thread.currentThread());
                }
            }).start();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    get(Thread.currentThread());
                }
            }).start();
        }
    }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 5][]

**从运行结果可以看出，两个线程的读操作是同时执行的，整个过程大概耗时100ms。**  
**通过两次实验的对比，我们可以看出来，ReetrantReadWriteLock的效率明显高于Synchronized关键字。**

# 3. ReetrantReadWriteLock读写锁互斥关系 #

> 通过上面的测试代码，我们也可以延伸得出一个结论，ReetrantReadWriteLock读锁使用共享模式，即：同时可以有多个线程并发地读数据。但是另一个问题来了，写锁之间是共享模式还是互斥模式？读写锁之间是共享模式还是互斥模式呢？下面让我们通过Demo进行一一验证吧。

## 3.1 ReetrantReadWriteLock读写锁关系 ##

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /**
     * 
     * ReetrantReadWriteLock实现
     *
     */
    public class ReadAndWriteLockTest {
    
    	public static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
        public static void main(String[] args) {
            //同时读、写
            ExecutorService service = Executors.newCachedThreadPool();
            service.execute(new Runnable() {
                @Override
                public void run() {
                    readFile(Thread.currentThread());
                }
            });
            service.execute(new Runnable() {
                @Override
                public void run() {
                    writeFile(Thread.currentThread());
                }
            });
        }
    
        // 读操作
        public static void readFile(Thread thread) {
            lock.readLock().lock();
            boolean readLock = lock.isWriteLocked();
            if (!readLock) {
                System.out.println("当前为读锁！");
            }
            try {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(thread.getName() + ":正在进行读操作……");
                }
                System.out.println(thread.getName() + ":读操作完毕！");
            } finally {
                System.out.println("释放读锁！");
                lock.readLock().unlock();
            }
        }
    
        // 写操作
        public static void writeFile(Thread thread) {
            lock.writeLock().lock();
            boolean writeLock = lock.isWriteLocked();
            if (writeLock) {
                System.out.println("当前为写锁！");
            }
            try {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(thread.getName() + ":正在进行写操作……");
                }
                System.out.println(thread.getName() + ":写操作完毕！");
            } finally {
                System.out.println("释放写锁！");
                lock.writeLock().unlock();
            }
        }
    }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 6][]

**结论：读写锁的实现必须确保写操作对读操作的内存影响。换句话说，一个获得了读锁的线程必须能看到前一个释放的写锁所更新的内容，读写锁之间为互斥。**

## 3.2 ReetrantReadWriteLock写锁关系 ##

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /**
     * 
     * ReetrantReadWriteLock实现
     *
     */
    public class ReadAndWriteLockTest {
    
    	public static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
        public static void main(String[] args) {
            //同时写
            ExecutorService service = Executors.newCachedThreadPool();
            service.execute(new Runnable() {
                @Override
                public void run() {
                    writeFile(Thread.currentThread());
                }
            });
            service.execute(new Runnable() {
                @Override
                public void run() {
                    writeFile(Thread.currentThread());
                }
            });
        }
    
        // 读操作
        public static void readFile(Thread thread) {
            lock.readLock().lock();
            boolean readLock = lock.isWriteLocked();
            if (!readLock) {
                System.out.println("当前为读锁！");
            }
            try {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(thread.getName() + ":正在进行读操作……");
                }
                System.out.println(thread.getName() + ":读操作完毕！");
            } finally {
                System.out.println("释放读锁！");
                lock.readLock().unlock();
            }
        }
    
        // 写操作
        public static void writeFile(Thread thread) {
            lock.writeLock().lock();
            boolean writeLock = lock.isWriteLocked();
            if (writeLock) {
                System.out.println("当前为写锁！");
            }
            try {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(thread.getName() + ":正在进行写操作……");
                }
                System.out.println(thread.getName() + ":写操作完毕！");
            } finally {
                System.out.println("释放写锁！");
                lock.writeLock().unlock();
            }
        }
    }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 7][]

# 4. 总结 #

1.Java并发库中ReetrantReadWriteLock实现了ReadWriteLock接口并添加了可重入的特性  
2.ReetrantReadWriteLock读写锁的效率明显高于synchronized关键字  
3.ReetrantReadWriteLock读写锁的实现中，读锁使用共享模式；写锁使用独占模式，换句话说，读锁可以在没有写锁的时候被多个线程同时持有，写锁是独占的  
4.ReetrantReadWriteLock读写锁的实现中，需要注意的，当有读锁时，写锁就不能获得；而当有写锁时，除了获得写锁的这个线程可以获得读锁外，其他线程不能获得读锁

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70]: /images/20210920/694ecc76392d44af97d05d53650ac046.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 1]: /images/20210920/90c7344547de452481998f8e43d709b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 2]: /images/20210920/2a907586284349e49ea8686aadb5644a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 3]: /images/20210920/67343b43c1644a069a1cf8318bba472a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 4]: /images/20210920/990b867cd7d14f80b3cfd64f5ae90147.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 5]: /images/20210920/74002222aba4410f88f4f2a127017aed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 6]: /images/20210920/748bcdbf1a104cd3921d8cb0648a2290.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE4Mjk4NDM5_size_16_color_FFFFFF_t_70 7]: /images/20210920/b78e642483124c36bb6a9fe9b611aaae.png