21、可重入排它锁ReentrantReadWriteLock使用详解

蔚落 2023-05-29 05:13 2阅读 0赞

ReentrantReadWriteLock是一把可重入读写锁，这篇文章主要是从使用的角度帮你理解，希望对你有帮助。

**一、性质**

**1、可重入**

如果你了解过synchronized关键字，一定知道他的可重入性，可重入就是同一个线程可以重复加锁，每次加锁的时候count值加1，每次释放锁的时候count减1，直到count为0，其他的线程才可以再次获取。

**2、读写分离**

我们知道，对于一个数据，不管是几个线程同时读都不会出现任何问题，但是写就不一样了，几个线程对同一个数据进行更改就可能会出现数据不一致的问题，因此想出了一个方法就是对数据加锁，这时候出现了一个问题：

> **线程写数据的时候加锁是为了确保数据的准确性，但是线程读数据的时候再加锁就会大大降低效率，这时候怎么办呢？那就对写数据和读数据分开，加上两把不同的锁，不仅保证了正确性，还能提高效率。**

**3、可以锁降级**

线程获取写入锁后可以获取读取锁，然后释放写入锁，这样就从写入锁变成了读取锁，从而实现锁降级的特性。

![在这里插入图片描述][2019110416065596.png]

**4、不可锁升级**

线程获取读锁是不能直接升级为写入锁的。需要释放所有读取锁，才可获取写锁，

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NERERMTEw_size_16_color_FFFFFF_t_70]  
我们理解了上面的概念之后，接下来我们看看如何去使用。

**二、使用**

**1、基本使用**

使用很简单，那就是在写方法和读方法分开使用两把锁。

public class ReadAndWriteLockTest { 
    	ReentrantReadWriteLock readAndWriteLock = new ReentrantReadWriteLock(true);
    	private final static Lock readLock = readAndWriteLock.readLock();
    	private final static Lock writeLock = readAndWriteLock.writeLock();
    	private final static List<String> data = new ArrayList<>();
    	public static void main(String[] args) { 
    		new Thread(()->write()).start();
    		new Thread(()->read()).start();
    	}
    }

（1）首先定义一个ReentrantReadWriteLock。

（2）通过上面readAndWriteLock分别获取readLock和writeLock。

（3）接下来定义一个List，用于指代数据。

（4）最后在main方法中，使用两个线程分别调用不同的方法。

我们看看读方法和写方法是如何实现的吧。

public static void write() throws InterruptedException { 
    		try { 
    			writeLock.lock();
    			data.add("写数据");
    			System.out.println(Thread.currentThread().getName()+":写数据");
    			TimeUnit.SECONDS.sleep(3);
    		}finally { 
    			writeLock.unlock();
    		}
    	}
    	public static void read() throws InterruptedException { 
    		try { 
    			readLock.lock();
    			for (String string : data) { 
    				System.out.println(Thread.currentThread().getName()+":读数据");
    			}
    			TimeUnit.SECONDS.sleep(3);
    		} finally { 
    			readLock.unlock();
    		}
    	}

在写方法中：使用writeLock获取一把写锁，然后内部List写入数据，最后在finally中释放写锁。

在读方法中：使用readLock获取一把读锁，然后内部List读取数据，最后再finally中释放读锁。

**2、锁升级**

升级的意思就是，读锁在获取写锁之前，一定要先释放读锁。看个例子。这个例子对oracle官网的例子改动了一下

public class ReadAndWriteLockTest2 { 
    	private final static ReentrantReadWriteLock readAndWriteLock 
    							= new ReentrantReadWriteLock(true);
    	private final static Lock readLock = readAndWriteLock.readLock();
    	private final static Lock writeLock = readAndWriteLock.writeLock();
    	private Map<String,String> map = new HashMap<>();
    	public static void main(String[] args) { 
    		ReadAndWriteLockTest2 test = new ReadAndWriteLockTest2();
            for (int i=0; i<4; i++) { 
                new Thread(()->{ 
                	System.out.println(Thread.currentThread().getName()+"启动");
                    test.writeAndRead();
                }).start();
            }
    	}
    }

在这里我们还是首先获取读锁和写锁，然后在main方法中定义了4个线程，执行writeAndRead方法。我们看看这个方法如何实现。

public void writeAndRead(){ 
    		//读数据
    		readLock.lock();
    		String readResult  = map.get("a");
    		if(readResult == null) { 
    			System.out.println("空数据，需要先写");
    			readLock.unlock();
    			writeLock.lock();
    			map.put("a","java的架构师技术栈");
    			writeLock.unlock();
    			System.out.println("写完了数据，写锁释放了");
    			//继续：读锁
    			readLock.lock();
    		}
    		System.out.println("读取的数据是："+readResult);
    		readLock.unlock();
    	}

在这个方法中，首先获取读锁，在获取写锁之前，一定要先释放读锁。这符合我们读写数据的一般规则。

**3、其他方法**

对于其他方面的使用，我们可以直接看读写锁的源码，其ReadLock是属于ReentrantReadWriteLock的内部类，在下一篇再说。一篇文章实在有点长。

public void lock() { 
                sync.acquireShared(1);
            }
            public void lockInterruptibly() throws InterruptedException { 
                sync.acquireSharedInterruptibly(1);
            }
            public boolean tryLock() { 
                return sync.tryReadLock();
            }
            public boolean tryLock(long timeout, TimeUnit unit)
                    throws InterruptedException { 
                return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
            }
            public void unlock() { 
                sync.releaseShared(1);
            }
        }

**lock：获取一个锁。**

**lockInterruptibly：可中断的获取锁。**

**tryLock：阻塞式获取锁，没有获取就一直等待，直到成功。**

**tryLock(long timeout, TimeUnit unit)：获取一个锁，在指定的时间内获取。**

**unlock：释放一个锁。**

k：获取一个锁。\*\*

**lockInterruptibly：可中断的获取锁。**

**tryLock：阻塞式获取锁，没有获取就一直等待，直到成功。**

**tryLock(long timeout, TimeUnit unit)：获取一个锁，在指定的时间内获取。**

**unlock：释放一个锁。**

其实对于ReentrantReadWriteLock的使用还是比较常见的，比如说缓存机制中。感谢大家支持。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NERERMTEw_size_16_color_FFFFFF_t_70 1]

[2019110416065596.png]: https://img-blog.csdnimg.cn/2019110416065596.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NERERMTEw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191104160702744.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NERERMTEw=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NERERMTEw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191104160715458.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NERERMTEw=,size_16,color_FFFFFF,t_70