ReentrantReadWriteLock读写锁简单示例

短命女 2022-12-26 12:29 153阅读 0赞

## 一、读写锁简介 ##

使用场景：对共享资源有读和写的操作，且写操作没有读操作那么频繁。在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程**同时读取**共享资源（共享锁）；但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写的操作了（排它锁）；

针对这种场景，JAVA的并发包提供了读写锁ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁，描述如下：

**线程进入读锁的前提条件：**

没有其他线程的写锁，

没有写请求或者有写请求，但调用线程和持有锁的线程是同一个。

**线程进入写锁的前提条件：**

没有其他线程的读锁

没有其他线程的写锁

而读写锁有以下三个重要的特性：

（1）公平选择性：支持非公平（默认）和公平的锁获取方式，吞吐量还是非公平优于公平。

（2）重进入：读锁和写锁都支持线程重进入。

（3）锁降级：遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级成为读锁。

**示例代码：**

import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReadWriteLock;
    import java.util.concurrent.locks.ReentrantLock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class T01_ReadWriteLock { 
    
        static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        static Lock readLock = readWriteLock.readLock();
        static Lock writeLock = readWriteLock.writeLock();
    
        public void read(Lock lock) throws InterruptedException { 
            lock.lock();
            Thread.sleep(1000);
            System.out.println("read");
            lock.unlock();
        }
    
        public void write(Lock lock) throws InterruptedException { 
            lock.lock();
            Thread.sleep(1000);
            System.out.println("write");
            lock.unlock();
        }
    
        public static void main(String[] args) { 
            T01_ReadWriteLock t = new T01_ReadWriteLock();
            Runnable read = ()-> { 
                try { 
                    t.read(readLock);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            };
            Runnable write = ()-> { 
                try { 
                    t.write(writeLock);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            };
    
            for(int i = 0;i<20;i++) { 
                new Thread(read).start();
            }
    
            for (int i = 0;i<3;i++) { 
                new Thread(write).start();
            }
        }
    
    }

read 几乎同时输出；write每隔一秒输出；，体现共享锁与排它锁的作用；