并发基础_9_并发_锁_读写锁_未详解

最新推荐文章于 2021-12-23 13:38:02 发布

Simba_cheng

最新推荐文章于 2021-12-23 13:38:02 发布

阅读量564

点赞数

分类专栏： Java_并发基础文章标签：多线程线程并发基础并发

本文链接：https://blog.csdn.net/Simba_cheng/article/details/77869832

版权

Java_并发基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

读写锁 - ReentrantReadWriteLock

读写锁简介

之前一篇文章，学习了解了ReentrantLock重入锁，这篇介绍ReentrantReadWriteLock读写锁。

从名字上看，这两个锁似乎存在某些联系？

现实情况是这两个锁没有半毛钱的关系，就像 Java和JavaScript，socket和webSocket，雷峰塔和雷锋，没有关系..

之前几篇文章提到的锁基本上都是排他锁(Mutex 和重入锁ReentrantLock)，这些锁在同一时间只允许一个线程进行访问，而读写锁在同一时间可以允许多个线程访问，但是在写线程访问时，所有的读线程和其他写线程全被阻塞。

读写锁维护了一个读锁和一个写锁，通过读写分离，使得并发性相比一般的排他锁有了很大提升。

简单理解：

读锁：允许多个线程获取

写锁：只允许一个线程获取

读锁与写锁互斥，同一时间，只能有一中锁存在。

在讲解AQS时候有过这样一张图，还记得嘛？

简单的说，当对临界资源读取的时候，允许其他多个线程读取，不允许写。

当对临界资源进行写操作的时候，只允许其一个线程进行操作，不允许其他线程写，也不允许线程读

一般情况下，读写锁的性能都会比排他锁好，因为大多数场景是读多于写。

在读多于写的情况，读写锁也能提供比排他锁更好的并发性和吞吐量。(原书说的，我没测试过╮(╯▽╰)╭)

读写锁Demo

一天到晚看理论源码真是日了狗了..

我们首先来写个Demo，当我们多线程读文件时，使用synchronized实现；

代码如下：

package com.concurrent.reentrantreadwritelock.reentrantreadwritelock_1;

public class ReadAndWriteLockTest {

public synchronized void get(Thread thread) {

	System.out.println("start time : " + System.currentTimeMillis());

	for (int i = 0; i < 5; i++) {

	try {
			Thread.sleep(20);
	} catch (Exception 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) {

	final ReadAndWriteLockTest testLock = new ReadAndWriteLockTest();

	new Thread(new Runnable() {

	@Override
	public void run() {
			testLock.get(Thread.currentThread());
	}
	}).start();

	new Thread(new Runnable() {

	@Override
	public void run() {
			testLock.get(Thread.currentThread());
	}
	}).start();

}
}

输出结果：
start time : 1500983087135
Thread-0正在读取操作...
Thread-0正在读取操作...
Thread-0正在读取操作...
Thread-0正在读取操作...
Thread-0正在读取操作...
Thread-0读取完毕..
end time : 1500983087294
start time : 1500983087294
Thread-1正在读取操作...
Thread-1正在读取操作...
Thread-1正在读取操作...
Thread-1正在读取操作...
Thread-1正在读取操作...
Thread-1读取完毕..
end time : 1500983087451

上述代码总共耗时：316ms

通过代码可以看到，在读取文件时，加上synchronized关键字之后，是互斥的..它的读不是共享的..

也就是说 thread-1必须等thread-0读完，才能读。

在高并发量的情况下，这肯定是不允许的，太浪费时间和性能了....

我们来看看使用读写锁的代码：

package com.concurrent.reentrantreadwritelock.reentrantreadwritelock_2;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadAndWriteLockTest2 {

// 读写锁
ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

public void get(Thread thread) {

	rwl.readLock().lock();// 获取读锁

	try {

	System.out.println("start time : " + System.currentTimeMillis());

	for (int i = 0; i < 5; i++) {
			try {
					Thread.sleep(20);
			} catch (Exception e) {
					e.printStackTrace();
			}
			System.out.println(thread.getName() + "正在进行读操作..");
	}
	System.out.println(thread.getName() + " 读取完毕..");
	System.out.println("end time : " + System.currentTimeMillis());

	} finally {
			rwl.readLock().unlock();
	}

}

public static void main(String[] args) {
	final ReadAndWriteLockTest2 lockTest2 = new ReadAndWriteLockTest2();

	new Thread(new Runnable() {

	@Override
	public void run() {
			lockTest2.get(Thread.currentThread());
	}
	}).start();

	new Thread(new Runnable() {

	@Override
	public void run() {
			lockTest2.get(Thread.currentThread());
	}
	}).start();

}

}

输出：
start time : 1500984194877
start time : 1500984194877
Thread-0正在进行读操作..
Thread-1正在进行读操作..
Thread-0正在进行读操作..
Thread-1正在进行读操作..
Thread-0正在进行读操作..
Thread-1正在进行读操作..
Thread-0正在进行读操作..
Thread-1正在进行读操作..
Thread-0正在进行读操作..
Thread-1正在进行读操作..
Thread-1 读取完毕..
Thread-0 读取完毕..
end time : 1500984195033
end time : 1500984195033

耗时：156ms

速度是不是快了好多呀....

thread-0 和 thread-1 同时读取文件，很明显可以看到读写锁的速度效率比synchronized快多了...

这个Demo并没有加上写锁，不过需要注意的是：如果有一个线程已经获取了读锁，那么如果其他线程要申请写锁，是要等待的。

一直等到读锁释放，另一个线程才能获取写锁。

同理，如果一个线程获取了写锁，另一个线程想获取读锁，也是要等待，等到写锁释放，才能获取读锁。

我们来看一个包含两种锁的Demo：

package com.concurrent.reentrantreadwritelock.reentrantreadwritelock_3;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ResdAndWriteLockTest {

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

public static void main(String[] args) {

	final ResdAndWriteLockTest lockTest = new ResdAndWriteLockTest();

	// 创建线程池，放入三个线程，同时读
	ExecutorService readService = Executors.newCachedThreadPool();
	for (int i = 0; i < 3; i++) {
			readService.execute(new Runnable() {

	@Override
	public void run() {
			lockTest.readFile(Thread.currentThread());
	}
	});
	}

	// 创建线程池，同时写
	ExecutorService writeService = Executors.newCachedThreadPool();
	writeService.execute(new Runnable() {

	@Override
	public void run() {
			lockTest.writeFile(Thread.currentThread());
	}
	});
}

// 读操作
public 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 (Exception e) {
			e.printStackTrace();
	}

	System.out.println(thread.getName() + "正在进行读操作...");
	}

	System.out.println(thread.getName() + "读操作完毕");

	} finally {
			System.out.println("释放读锁");
			lock.readLock().unlock();
	}
}

// 写操作
public 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 (Exception e) {
			e.printStackTrace();
	}

	System.out.println(thread.getName() + "正在进行写操作");

	}

	System.out.println(thread.getName() + " 写操作完毕");

	} finally {
			System.out.println("释放写锁");
			lock.writeLock().unlock();
	}

}

}
输出结果：
当前是读锁╮(╯▽╰)╭
当前是读锁╮(╯▽╰)╭
当前是读锁╮(╯▽╰)╭
pool-1-thread-3正在进行读操作...
pool-1-thread-1正在进行读操作...
pool-1-thread-2正在进行读操作...
pool-1-thread-2正在进行读操作...
pool-1-thread-3正在进行读操作...
pool-1-thread-1正在进行读操作...
pool-1-thread-1正在进行读操作...
pool-1-thread-3正在进行读操作...
pool-1-thread-2正在进行读操作...
pool-1-thread-2正在进行读操作...
pool-1-thread-1正在进行读操作...
pool-1-thread-3正在进行读操作...
pool-1-thread-2正在进行读操作...
pool-1-thread-2读操作完毕
释放读锁
pool-1-thread-1正在进行读操作...
pool-1-thread-1读操作完毕
释放读锁
pool-1-thread-3正在进行读操作...
pool-1-thread-3读操作完毕
释放读锁
当前为写锁...╮(╯▽╰)╭
pool-2-thread-1正在进行写操作
pool-2-thread-1正在进行写操作
pool-2-thread-1正在进行写操作
pool-2-thread-1正在进行写操作
pool-2-thread-1正在进行写操作
pool-2-thread-1 写操作完毕
释放写锁

从上面Demo的输出结果看..

pool-1-thread-1，pool-1-thread-2，pool-1-thread-3一起进行了读操作，没有影响。

然后三次释放读锁..

接着，pool-2-thread-1 才获取到写锁，进行写操作

读写锁ReentReadWriteLock实现分析

(这里不对读写锁进行深扒，了解就好，看得懂看看，看不懂也没关系)

读写锁内部也是依赖于自定义同步器(AQS)来实现同步功能，读写的状态就是内部同步器的状态。

还记得之前文章介绍的重入锁ReentrantLock吗？

ReentrantLock中自定义同步器的实现，同步状态表示为锁被一个线程重复获取的次数。

而读写锁的自定义同步器需要在同步状态(一个整型变量)上维护多个读线程和一个写线程的状态。

如果在一个整型变量上维护多种状态，需要"按位切割"使用这个变量；

读写锁将变量切分成了两个部分，高16位表示读，低16位表示写，如下图(图片来自原书)