二十六. 并发实战-读写锁的使用

曾经终败给现在 2024-03-27 08:48 26阅读 0赞

### 前言 ###

`JUC`并发包中提供了`ReentrantReadWriteLock`作为读写锁，本篇文章将对读写锁的如下四个场景进行演示。

1.  当前线程获取`读锁`时，`读锁`是否被获取不会影响`读锁`的获取；
2.  当前线程获取`读锁`时，若`写锁`未被获取或者`写锁`被当前线程获取，则允许获取`读锁`，否则进入等待状态；
3.  当前线程获取`写锁`时，若`读锁`已经被获取，无论获取`读锁`的线程是否是当前线程，都进入等待状态；
4.  当前线程获取`写锁`时，若`写锁`已经被其它线程获取，则进入等待状态。

### 正文 ###

#### 一. 场景一 ####

本小节演示：当前线程获取`读锁`时，`读锁`是否被获取不会影响`读锁`的获取。示例如下。

public class ReentrantReadWriteLockTest {
        
    
        @Test
        public void 当前线程获取读锁_读锁是否被获取不会影响读锁的获取() throws Exception {
        
            // 创建读写锁
            ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
            Lock readLock = reentrantReadWriteLock.readLock();
    
            // 创建CountDownLatch对象
            CountDownLatch countDownLatch = new CountDownLatch(2);
    
            // 创建任务
            Runnable readLockRunnable1 = new Runnable() {
        
                @Override
                public void run() {
        
                    readLock.lock();
                    try {
        
                        System.out.println(Thread.currentThread().getName() + " 获取读锁");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        // ignore
                    } finally {
        
                        readLock.unlock();
                        countDownLatch.countDown();
                    }
                }
            };
            Runnable readLockRunnable2 = new Runnable() {
        
                @Override
                public void run() {
        
                    readLock.lock();
                    try {
        
                        System.out.println(Thread.currentThread().getName() + " 获取读锁");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        // ignore
                    } finally {
        
                        readLock.unlock();
                        countDownLatch.countDown();
                    }
                }
            };
    
            // 线程1先获取读锁
            Thread thread1 = new Thread(readLockRunnable1, "线程1");
            thread1.start();
    
            // 线程2再获取读锁
            Thread thread2 = new Thread(readLockRunnable2, "线程2");
            thread2.start();
    
            // 阻塞主线程
            countDownLatch.await();
        }
    
    }

上述示例中，演示了线程1和线程2先后获取读锁，如果获取到读锁，则打印一条日志。运行测试程序，结果如下。

![在这里插入图片描述][9231ada1af67438daff17a39009af8d8.jpeg_pic_center]

运行结果表明，当前线程获取`读锁`时，`读锁`是否被获取不会影响`读锁`的获取。

#### 二. 场景二 ####

本小节演示：当前线程获取`读锁`时，若`写锁`未被获取或者`写锁`被当前线程获取，则允许获取`读锁`，否则进入等待状态。示例如下。

public class ReentrantReadWriteLockTest {
        
    
        @Test
        public void 当前线程获取读锁_若写锁已经被当前线程获取则当前线程能获取到读锁() throws Exception {
        
            // 创建读写锁
            ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
            Lock readLock = reentrantReadWriteLock.readLock();
            Lock writeLock = reentrantReadWriteLock.writeLock();
    
            // 创建CountDownLatch对象
            CountDownLatch countDownLatch = new CountDownLatch(1);
    
            // 创建任务
            Runnable runnable = new Runnable() {
        
                @Override
                public void run() {
        
                    // 先拿写锁
                    writeLock.lock();
                    try {
        
                        System.out.println(Thread.currentThread().getName() + " 获取到了写锁");
                        // 同一线程中再拿读锁
                        if (readLock.tryLock()) {
        
                            try {
        
                                System.out.println(Thread.currentThread().getName() + " 获取到了读锁");
                            } finally {
        
                                readLock.unlock();
                            }
                        }
                    } finally {
        
                        writeLock.unlock();
                        countDownLatch.countDown();
                    }
                }
            };
    
            // 创建线程
            Thread thread = new Thread(runnable, "线程1");
            thread.start();
    
            // 阻塞主线程
            countDownLatch.await();
        }
    
    }

上述示例中，演示了同一线程先后获取写锁和读锁，获取到对应锁后，打印日志。运行测试程序，结果如下所示。

![在这里插入图片描述][0d616036ea4d47579d719076b989bc58.jpeg_pic_center]

运行结果表明，当前线程获取`读锁`时，若`写锁`被当前线程获取，则允许获取`读锁`。

再看如下示例。

public class ReentrantReadWriteLockTest {
        
    
        @Test
        public void 当前线程获取读锁_若写锁已经被其它线程获取则当前线程无法获取读锁() throws Exception {
        
            // 创建读写锁
            ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
            Lock readLock = reentrantReadWriteLock.readLock();
            Lock writeLock = reentrantReadWriteLock.writeLock();
    
            // 创建CountDownLatch对象
            CountDownLatch countDownLatch = new CountDownLatch(2);
    
            // 创建拿写锁的任务
            Runnable writeLockRunnable = new Runnable() {
        
                @Override
                public void run() {
        
                    writeLock.lock();
                    try {
        
                        System.out.println(Thread.currentThread().getName() + " 获取到了写锁");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        // ignore
                    } finally {
        
                        writeLock.unlock();
                        countDownLatch.countDown();
                    }
                }
            };
            // 创建拿读锁的任务
            Runnable readLockRunnable = new Runnable() {
        
                @Override
                public void run() {
        
                    if (readLock.tryLock()) {
        
                        try {
        
                            System.out.println(Thread.currentThread().getName() + " 获取到了读锁");
                        } finally {
        
                            readLock.unlock();
                        }
                    } else {
        
                        System.out.println(Thread.currentThread().getName() + " 获取读锁失败");
                    }
                    countDownLatch.countDown();
                }
            };
    
            // 创建线程拿写锁
            Thread thread1 = new Thread(writeLockRunnable, "线程1");
            thread1.start();
    
            // 创建线程拿读锁
            Thread thread2 = new Thread(readLockRunnable, "线程2");
            thread2.start();
    
            countDownLatch.await();
        }
    
    }

上述示例中，演示了线程1先获取写锁，线程2后获取读锁，并打印获取结果。运行测试程序，结果如下。

![在这里插入图片描述][d1aa4555bfa3400e871ae7bd2e63b861.jpeg_pic_center]  
运行结果表明：当前线程获取`读锁`时，若`写锁`已被其它线程获取，则获取失败。

#### 三. 场景三 ####

本小节演示：当前线程获取`写锁`时，若`读锁`已经被获取，无论获取`读锁`的线程是否是当前线程，都进入等待状态。示例如下。

public class ReentrantReadWriteLockTest {
        
    
        @Test
        public void 当前线程获取写锁_若读锁已被当前线程获得则当前线程无法获取写锁() {
        
            // 创建读写锁
            ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
            Lock readLock = reentrantReadWriteLock.readLock();
            Lock writeLock = reentrantReadWriteLock.writeLock();
    
            // 创建CountDownLatch对象
            CountDownLatch countDownLatch = new CountDownLatch(1);
    
            // 创建任务
            Runnable runnable = new Runnable() {
        
                @Override
                public void run() {
        
                    // 先拿读锁
                    readLock.lock();
                    try {
        
                        System.out.println(Thread.currentThread().getName() + " 获取到了读锁");
                        // 同一线程中再拿写锁
                        if (writeLock.tryLock()) {
        
                            try {
        
                                System.out.println(Thread.currentThread().getName() + " 获取到了写锁");
                            } finally {
        
                                writeLock.unlock();
                            }
                        } else {
        
                            System.out.println(Thread.currentThread().getName() + " 获取写锁失败");
                        }
                    } finally {
        
                        readLock.unlock();
                        countDownLatch.countDown();
                    }
                }
            };
    
            // 创建线程并执行任务
            Thread thread = new Thread(runnable, "线程1");
            thread.start();
    
            // 阻塞主线程
            countDownLatch.countDown();
        }
    
    }

上述示例中，演示了同一线程先获取读锁，再获取写锁，并打印获取结果。运行测试程序，结果如下。

![在这里插入图片描述][67e63701527244c58ab9c6020dafe45e.jpeg_pic_center]

运行结果表明：当前线程获取`写锁`时，若`读锁`已经被获取，无论获取`读锁`的线程是否是当前线程，都获取失败。

#### 四. 场景四 ####

本小节演示：当前线程获取`写锁`时，若`写锁`已经被其它线程获取，则进入等待状态。示例如下。

public class ReentrantReadWriteLockTest {
        
    
        @Test
        public void 当前线程获取写锁_若写锁已经被其它线程获取则获取失败() throws Exception {
        
            // 创建读写锁
            ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
            Lock writeLock = reentrantReadWriteLock.writeLock();
    
            // 创建CountDownLatch对象
            CountDownLatch countDownLatch = new CountDownLatch(2);
    
            // 创建拿写锁的任务
            Runnable writeLockRunnable = new Runnable() {
        
                @Override
                public void run() {
        
                    if (writeLock.tryLock()) {
        
                        try {
        
                            System.out.println(Thread.currentThread().getName() + " 获取到了写锁");
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
        
                            // ignore
                        } finally {
        
                            writeLock.unlock();
                        }
                    } else {
        
                        System.out.println(Thread.currentThread().getName() + " 获取写锁失败");
                    }
                    countDownLatch.countDown();
                }
            };
    
            // 创建线程1，拿写锁
            Thread thread1 = new Thread(writeLockRunnable, "线程1");
            thread1.start();
    
            // 创建线程2，拿写锁
            Thread thread2 = new Thread(writeLockRunnable, "线程2");
            thread2.start();
    
            // 阻塞主线程
            countDownLatch.await();
        }
    
    }

上述示例中，演示了线程1先获取写锁，线程2后获取写锁，并打印获取结果。运行测试程序，结果如下。

![在这里插入图片描述][e2355f151e39453eb0960bb0d5e547c2.jpeg_pic_center]

上述结果表明：当前线程获取`写锁`时，若`写锁`已经被其它线程获取，则获取失败。

### 总结 ###

读写锁`ReentrantReadWriteLock`的使用流程通常如下。

1.  创建`ReentrantReadWriteLock`对象；
2.  通过`ReentrantReadWriteLock`的`readLock()`方法创建`读锁ReentrantReadWriteLock.WriteLock`；
3.  通过`ReentrantReadWriteLock`的`writeLock()`方法创建`写锁ReentrantReadWriteLock.ReadLock`；
4.  后续加`读锁`通过`ReentrantReadWriteLock.WriteLock`，加`写锁`通过`ReentrantReadWriteLock.ReadLock`。

读写锁的使用规则总结如下。

读锁和写锁加锁时有两种方式。

1.  通过`lock()`方法加锁，失败则进入同步队列等待；
2.  通过`tryLock()`方法加锁，成功返回**true**，失败返回**false**。

[9231ada1af67438daff17a39009af8d8.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/cdb7ab5598f84f81b99fd5223471af57.png
[0d616036ea4d47579d719076b989bc58.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/08e543f81172479a9b83092f78cd32a7.png
[d1aa4555bfa3400e871ae7bd2e63b861.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/9449e05650964eeeb2c47e3ab6628ab9.png
[67e63701527244c58ab9c6020dafe45e.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/7a4843002a654d09b77e633522341ddc.png
[e2355f151e39453eb0960bb0d5e547c2.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/9f5cd8406ec04d4d80f903588145e3af.png