【并发编程】可重入锁和读写锁

最新推荐文章于 2023-03-31 17:29:21 发布
最新推荐文章于 2023-03-31 17:29:21 发布
阅读量209 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdaujsj1/article/details/103193567
版权

可重入锁ReentrantLock

何为重入：
重进入是指任意线程在获取到锁之后能够再次获取该锁而不会被锁阻塞

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class UseReentrantLock {
	
	private Lock lock = new ReentrantLock();
	
	public void method1(){
		try {
			lock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1..");
			Thread.sleep(1000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1..");
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			
			lock.unlock();
		}
	}
	
	public void method2(){
		try {
			lock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method2..");
			Thread.sleep(2000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method2..");
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {

		final UseReentrantLock ur = new UseReentrantLock();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				ur.method1();
				ur.method2();
			}
		}, "t1");

		t1.start();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//System.out.println(ur.lock.getQueueLength());
	}
	
	
}

运行结果：
在这里插入图片描述

一般使用lock.lock();就try catch 在finally里释放锁：lock.unlock(); 功能和synchronized差不多 比synchronized轻量

在使用synchronized的时候 多线程间进行协作工作需要通过wait() notify() 进行配合工作

使用Lock的时候 使用Condition类来等待和通知现场 Condition针对的是具体某一把锁

Lock Condition 的使用：

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class UseCondition {

	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	
	public void method1(){
		try {
			lock.lock();
			System.out.println("当前线程：" + Thread.currentThread().getName() + "进入等待状态..");
			Thread.sleep(3000);
			System.out.println("当前线程：" + Thread.currentThread().getName() + "释放锁..");
			condition.await();	// 相当于Object wait 阻塞 等待signal();
			System.out.println("当前线程：" + Thread.currentThread().getName() +"继续执行...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void method2(){
		try {
			lock.lock();
			System.out.println("当前线程：" + Thread.currentThread().getName() + "进入..");
			Thread.sleep(3000);
			System.out.println("当前线程：" + Thread.currentThread().getName() + "发出唤醒..");
			condition.signal();		//相当于 Object notify
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		
		final UseCondition uc = new UseCondition();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				uc.method1();
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				uc.method2();
			}
		}, "t2");
		t1.start();

		t2.start();
	}
	
	
	
}

运行结果：
在这里插入图片描述

多Condition下Lock

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class UseManyCondition {

	private ReentrantLock lock = new ReentrantLock();
	private Condition c1 = lock.newCondition();
	private Condition c2 = lock.newCondition();
	
	public void m1(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m1等待..");
			c1.await();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m1继续..");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void m2(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m2等待..");
			c1.await();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m2继续..");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void m3(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m3等待..");
			c2.await();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m3继续..");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void m4(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
			c1.signalAll();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void m5(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
			c2.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		
		
		final UseManyCondition umc = new UseManyCondition();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m1();
			}
		},"t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m2();
			}
		},"t2");
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m3();
			}
		},"t3");
		Thread t4 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m4();
			}
		},"t4");
		Thread t5 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m5();
			}
		},"t5");
		
		t1.start();	// c1
		t2.start();	// c1
		t3.start();	// c2
		

		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		t4.start();	// c1
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t5.start();	// c2
		
	}
	
	
	
}

运行结果：
在这里插入图片描述
结果分析：
线程1 2 4 对应一个Condition 线程4唤醒线程1和2
线程3 5 对应另一个Condition 线程5唤醒线程3

ReentrantReadWriteLock 读写锁

读写锁ReentrantReadWriteLock 核心是实现读写分离的锁 在高并发访问下 尤其是读多写少 性能远高于重入锁
本质是分成两个锁 读锁和写锁 在读锁下 多个线程可以并发的进行访问 但在写锁的时候 只能一个个的顺序访问
读读共享 写写互斥 读写互斥

上代码：

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class UseReentrantReadWriteLock {

	private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
	private ReadLock readLock = rwLock.readLock();
	private WriteLock writeLock = rwLock.writeLock();
	
	public void read(){
		try {
			readLock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
			Thread.sleep(3000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			readLock.unlock();
		}
	}
	
	public void write(){
		try {
			writeLock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
			Thread.sleep(3000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			writeLock.unlock();
		}
	}
	
	public static void main(String[] args) {
		
		final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
		
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.read();
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.read();
			}
		}, "t2");
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.write();
			}
		}, "t3");
		Thread t4 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.write();
			}
		}, "t4");		
		
		t1.start();
		t2.start();
		
//		t1.start(); // R 
//		t3.start(); // W
		
		t3.start();
		t4.start();
		
		
		
		
		
		
		
		
	}
}

运行结果：
在这里插入图片描述

线程3和4 是写操作 顺序执行 线程1 2 是读操作 同时进入和退出

想上岸的小写
关注
Java并发编程系列---可重入锁和读写锁的实现原理、源码分析
逆流而上的博客
02-11 1051
一、重入锁 1.1 什么是重入锁 重入锁ReentrantLock，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。除此之外，该锁的还支持获取锁时的公平和非公平性选择。 1.2 重入锁有什么用 例子：之前AQS的一个自己实现的锁 package com.example.demo.thread; import java.util.concurrent.TimeUnit; impor...
多线程学习总结（四）：可重入锁和读写锁
weixin_42882828的博客
09-09 926
多线程学习总结（四）：可重入锁和读写锁。 ReenTrantLock可重入锁 ReentrantReadWriteLock，可重入读写锁 之前学习了线程同步和线程间通信的相关技能，我们主要通过synchronized关键字和通知等待机制去实现上述功能的，除此之外，java提供了功能更强大，使用更方便的Lock接口及实现类，常见的如ReenTrantLock和ReentrantReadWri...
多线程（五）可重入锁、读写锁
HK的博客
10-16 1568
ReentrantLock、ReentrantReadWriteLock
ReentrantReadWriteLock可重入读写锁分析
weixin_33716557的博客
07-05 236
ReentrantReadWriteLock 可重入的读写锁 什么叫可重入：就是同一个线程可以重复加锁，可以对同一个锁加多次，每次释放的时候回释放一次，直到该线程加锁次数为0，这个线程才释放锁。 什么叫读写锁： 也就是读锁可以共享，多个线程可以同时拥有读锁，但是写锁却只能只有一个线程拥有，而且获取写锁的时候，其他线程都已经释放了读锁，而且在该线程获取写锁之后，其他线程不能再获取读锁...
重入锁与读写锁
...
06-21 371
重入锁 重入锁ReentrantLock就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。除此之外，该锁还支持获取锁时的公平和非公平性选择。 synchronized关键字隐式的支持重进入，比如一个synchronized修饰的递归方法，在方法执行时，执行线程在获取了锁之后仍能连续多次地获得该锁。 ReentrantLock虽然没能像synchronized关键字一样支持隐式的重进入，但是在调用lock方法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不是被阻塞。 这里提到一个锁
Java并发编程之重入锁与读写锁
08-29
在 Java 并发编程中，重入锁和读写锁是两个非常重要的概念。重入锁是指支持重进入的锁，也就是说，一个线程可以多次获取同一个锁，而不会被阻塞。读写锁则是维护了一对相关的锁，一用于只读操作，另一用于写入操作。...
Java并发编程之显示锁ReentrantLock和ReadWriteLock读写锁
09-03
ReentrantLock是一个可重入的锁，这意味着一个线程可以多次获取同一锁，这与synchronized内置锁的行为相同。然而，与内置锁不同的是，使用ReentrantLock需要显式调用`lock()`和`unlock()`方法来获取和释放锁，这增加...
GO语言并发编程之互斥锁、读写锁详解
01-20
这包括了互斥锁和读写锁。我们在第6章描述过互斥锁，但却没有提到过读写锁。这两种锁对于传统的并发程序来说都是非常常用和重要的。 一、互斥锁 互斥锁是传统的并发程序对共享资源进行访问控制的主要手段。它由标准...
python并发编程多进程 互斥锁原理解析
09-18
本文将详细解析Python多进程并发编程中互斥锁的原理和应用，通过具体的代码示例来进行说明。 首先，需要了解的是，在Python中，多进程是指创建多个进程，让它们并发地执行不同的任务，这在需要利用多核CPU处理多个...
Elasticsearch分词
weixin_46034226的博客
12-30 329
一、 analysis与analyzer analysis：   文本分析，是将全文本转换为一系列单词的过程，也叫分词。analysis是通过analyzer(分词器)来实现的，可以使用Elasticearch内置的分词器，也可以自己去定制一些分词器。除了在数据写入时将词条进行转换，那么在查询的时候也需要使用相同的分析器对语句进行分析。 analyzer(分词器)： 由三部分组成： Charac...
AQS的应用：可重入锁和读写锁
csdn_binger的博客
10-11 303
一、Lock接口 1、Lock ​ Lock跟Synchronized一样，都是用在多线程中用来控制并发，保证共享资源安全的一种同步机制。 Synchronized是隐式的加锁/解锁;而Lock是显示的加锁/解锁，也就是说我们使用的时候需要先lock.lock()锁定资源，执行逻辑，用完后在lock.unlock()释放资源。 2、特性 ​ Lock有Synchronized没有的特性，这几个特性使我们在开发中更方便灵活 ​ 1、非阻塞性获取同步状态。tryLock方法可以立即返回是否获取到同步状态，先尝试
可重入锁ReentrantLock和可重入读写锁ReentrantReadWriteLock
river66的博客
06-14 275
ReentrantLock和synchronized都是可重入锁，可重入锁的意思是：拥有锁的代码块中可以继续去获取锁。 public synchronized void out(){//锁的是this对象，但是看不到锁 //doSomething in(); } public synchronized void in(){ ...
java 读写锁_Java并发编程之重入锁与读写锁
weixin_32042959的博客
02-12 155
重入锁重入锁，顾名思义，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。重进入是指任意线程在获取到锁之后能够再次获取该锁而不会被锁阻塞，该特性的实现需要解决以下两个问题。1、线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。2、锁的最终释放。线程重复n次获取了锁，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数...
可重入锁和读写锁的源码分析
Jarvan_Song的博客
08-25 680
可重入锁和读写锁的源码分析
并发编程-读写锁
tyroxyz的博客
07-13 239
读写锁 ReentrantReadWriteLock 当读操作远远髙于写操作时,这时候使用读写锁让读-读可以并发,提高性能。 类似于数据库中的 select…from…lock in share mode 提供一个数据容器类内部分别使用读锁保护数据的read()方法,写锁保护数据的write()方法 public class TestReadWriteLock { public static void main(String[] args) { DataContainer data
可重入锁、读写锁、邮戳锁 详解
最新发布
King Gigi的博客
03-31 788
无锁、独占锁、读写锁、邮戳锁的演变
读写锁 & 可重入锁
weixin_44660094的博客
08-02 750
#读写锁是什么？ 读写锁就是分了两种情况，一种是读时的锁，一种是写时的锁，它允许多个线程同时读共享变量，但是只允许一个线程写共享变量，当写共享变量的时候也会阻塞读的操作。这样在读的时候就不会互斥，提高读的效率。 #可重入锁是什么？ 可重入锁指的是在同一个线程内如果你的外层函数已经获得了锁，那么当你的内层函数也能获取锁，也就是通过一个线程再次进入同步代码块时可以获得自己已经获得的锁，而不可重入则反之。看下简单的示例 public void doSth(){ //外层函数 lock.loc
可重入的读写锁-ReentrantReadWriteLock及AQS源码分析
JavaEdge全是干货的技术号
10-19 2058
1 读写锁维护了一对相关的锁，一个用于只读操作，一个用于写入操作。 只要没有writer，读锁可以由多个reader线程同时保持。 写锁是独占的。 互斥锁一次只允许一个线程访问共享数据，哪怕进行的是只读操作 读写锁允许对共享数据进行更高级别的并发访问 对于写操作，一次只有一个线程（write线程）可以修改共享数据 对于读操作，允许任意数量的线程同时进行读取。 与互斥锁相比，使用读写锁能否...
ReentrantReadWriteLock----可重入读写锁
Calm的博客
02-28 273
读写锁：允许同一时刻被多个读线程访问，但是在写线程访问时，所有的读线程与其他的写线程均会阻塞。 写线程能够获取到锁的前提条件：没有任何读、写线程拿到锁。 1. 写锁-WriteLock-独占锁 1.1 写锁的获取 - 模板方法tryAcquire() 源码： protected final boolean tryAcquire(int acquires) { /* ...
Go语言并发编程：互斥锁与读写锁深入解析
理解并熟练运用互斥锁和读写锁是Go语言并发编程的基础，合理的锁策略能有效提高程序的并发性能和稳定性。遵循锁定与解锁成对的原则，以及利用Go语言的特性（如`defer`）是编写高效并发代码的关键。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值