java多线程之ReentrantReadWriteLock

梦里梦外; 2022-05-17 13:20 225阅读 0赞

读写锁拆成读锁和写锁来理解。读锁可以共享，多个线程可以同时拥有读锁，但是写锁却只能只有一个线程拥有，而且获取写锁的时候其他线程都已经释放了读锁(没有人在读)，而且该线程获取写锁之后，其他线程不能再获取读锁。简单的说就是写锁是排他锁，读锁是共享锁。读锁可以共享，即同一个资源可以让多个线程获取读锁。这个和ReentrantLock（或者sychronized）相比大大提高了读的性能。在需要对资源进行写入的时候在会加写锁达到互斥的目的。

简单理解为就是一个人在写书，写书的时候你不能去读（因为是不完整的），但是当这个人写完时，这书可以卖给多个人，多个人可以同时读。

示例代码：

ReadWriteLockTest类：

public class ReadWriteLockTest {
    	
    	private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    	private ReadLock readLock = readWriteLock.readLock();
    	private WriteLock writeLock = readWriteLock.writeLock();
    	private String testData = "这里是文件的内容";
    	
    	public void write() throws InterruptedException {
    		
    		System.out.println(Thread.currentThread().getName() + "等待资源释放...");
    		writeLock.lock();
    		System.out.println(Thread.currentThread().getName() + "线程正在修改此文件");
    		for(int i = 0; i < 40; i ++) {
    			testData = testData + "新写入：" + i;
    			System.out.println(Thread.currentThread().getName() + "线程写入" + "\"\"新写入：\"" + i);
    			Thread.sleep(50);
    		}
    		writeLock.unlock();
    	}
    	
    	public void read() throws InterruptedException {
    		
    		System.out.println(Thread.currentThread().getName() + "等待写锁释放...");
    		readLock.lock();
    		System.out.println(Thread.currentThread().getName() + "线程正在读取此文件，读取内容为：" + testData);
    		Thread.sleep(50);
    		readLock.unlock();	
    	}
    }

Main类：

public class Main {
    	
    	public static void main(String[] args) throws Exception {
    		
    		System.out.println("------ReentrantReadWriteLock测试----------");
    		final ReadWriteLockTest readWriteLockTest = new ReadWriteLockTest();
                    //3个写线程
    		for(int i = 0; i < 3; i ++) {
    			new Thread(new Runnable() {
    				
    				public void run() {
    					try {
    						readWriteLockTest.write();
    					} catch (InterruptedException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
    			}).start();
    		}
                    //10个读线程
    		for(int i = 0; i < 10; i ++) {
    			new Thread(new Runnable() {
    				
    				public void run() {
    					try {
    						readWriteLockTest.read();
    					} catch (InterruptedException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
    			}).start();
    		}
    	}
    }

测试结果：

![70][]![70 1][]![70 2][]

上例中，我们创建了3个写线程，10个读线程，我们从测试结果可以看到写线程是一个一个执行的，只有等待前一个写完后，下一个才能写，并且写的过程中是不能读的。而读线程是10个线程同时读的。

[70]: https://img-blog.csdn.net/20180812151715850?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDc1NDI1/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 1]: https://img-blog.csdn.net/20180812151747548?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MDc1NDI1/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 2]: /images/20220517/9b7913c7a730415485d39334499fc4ed.png