锁

最新推荐文章于 2024-03-21 10:30:00 发布
最新推荐文章于 2024-03-21 10:30:00 发布
阅读量255 收藏
点赞数
分类专栏： 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010634288/article/details/54026848
版权

在java多线程中，我们知道synchronized关键字可以实现线程之间的同步互斥工作。我们也可以用Lock来完成这个工作，这里有2种锁：重入锁和读写锁，他们有嗅探锁定、多路分支的功能。

一、重入锁

1、重入锁需要在代码块中加上锁定，但最后一定要记得释放锁定，不然会造成锁永远无法释放，其他线程进不来的结果。

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());
	}

打印结果：

当前线程:t1进入method1..
当前线程:t1退出method1..
当前线程:t1进入method2..
当前线程:t1退出method2..



2、Condition 

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
			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();
	}
	
	
	
}



当前线程：t1进入等待状态..
当前线程：t1释放锁..
当前线程：t2进入..
当前线程：t2发出唤醒..
当前线程：t1继续执行...





3、多个Condition

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
		
	}
	
	
	
}


打印结果：

当前线程：t1进入方法m1等待..
当前线程：t2进入方法m2等待..
当前线程：t3进入方法m3等待..
当前线程：t4唤醒..
当前线程：t1方法m1继续..
当前线程：t2方法m2继续..
当前线程：t5唤醒..
当前线程：t3方法m3继续..


二、读写锁

读写锁ReentrantReadWriteLock，其核心就是实现读写分离的锁。在高并发访问下尤其是读多写少的情况下，性能远高于重入锁

之前学的synchronized、ReentrantLock，我们知道，同一个时间内只能有一个线程进行访问被锁定的代码。那么读写锁则不同，其本质是分成2个锁，即读锁和写锁，在读锁下，多个线程可以高并发的进行访问，但是在写锁的时候，只能一个一个的顺序访问

口诀：读读共享，写写互斥，读写互斥

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();

		
	}
}

打印结果：

当前线程:t3进入...
当前线程:t3退出...
当前线程:t4进入...
当前线程:t4退出...




 

Mr_蜗牛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
安卓锁机源码
02-15
在安卓平台上，锁机应用是一种常见的安全工具，用于保护设备免受未经授权的访问。源码是开发者进行二次开发或学习编程的重要参考资料。标题中的“安卓锁机源码”指的是一个用于创建安卓设备锁定功能的应用程序源代码...
云熙设计免锁版
06-14
"云熙设计免锁版"是一款专为家具设计领域打造的专业软件，主要针对板式家具的设计制作。这款软件因其无需授权的特性，受到许多工厂和个人设计师的欢迎，尤其适合小型工厂或初学者进行试用和学习。在描述中提到，云熙...
【MySQL】记录锁？间隙锁？临键锁？到底锁了些什么？这一篇帮你捋清楚(￣∇￣)/
aqin1012的博客
04-15 25万+
LOCK_MODE列中为X，即加了临键锁，锁住的范围是LOCK_DATA中的行数据以及其前间隙（左开右闭）LOCK_MODE列中为X,REC_NOT_GAP，锁住的是LOCK_DATA中的行数据LOCK_MODE列中为X,GAP，锁住的是LOCK_DATA中的行数据前面的间隙（左开右开）
面试必备之乐观锁与悲观锁
热门推荐
JavaGuide
07-16 29万+
悲观锁总是假设最坏的情况，认为共享资源每次被访问的时候就会出现问题(比如共享数据被修改)，所以每次在获取资源操作的时候都会上锁，这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说，共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程。像 Java 中和等独占锁就是悲观锁思想的实现。悲观锁通常多用于写多比较多的情况下（多写场景），避免频繁失败和重试影响性能。
【多线程与高并发】- synchronized锁的认知
qq_43843951的博客
02-19 22万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
阿里面试，问了我乐观锁、悲观锁、AQS、sync和Lock，这个回答让我拿了offer
敖丙
03-06 15万+
很多东西都有点忘记了，不过回答总体是没大问题的
Java锁机制深度解析与实战应用
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-21 4万+
深入理解和熟练掌握Java中的锁机制是构建高效、稳定多线程程序的关键所在。开发者应依据具体的并发场景，权衡锁的开销与安全性，合理选择并应用合适的锁实现。
MySQL锁详解
hxt的博客
06-05 9万+
根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类 一、全局锁 全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flush tables with read lock。当需要让整个库处于只读状态的时候，可以使用这个命令，之后其他线程的以下语句会被阻塞：数据更新语句（数据的增删改）、数据定义语句（包括建表、修改表结构等）和更新类事务的提交语句 全局锁的......
Java面试——锁
程序猿进阶
02-26 6037
在并发环境中，每个线程在获取锁时会先查看此锁维护的队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照 FIFO 的规则从队列中取到自己。指多个线程获取锁的顺序并不是按照申请锁的顺序，上来就尝试占有锁，如果尝试失败，就再采用类似公平锁的方式获取锁。【4】不适合计算密集型任务：如果任务主要是计算密集型的，使用自旋锁可能会导致性能下降，因为自旋锁会占用CPU资源，而在计算密集型任务中，减少锁的使用可能是更优的选择。类型来得到公平锁或非公平锁，默认是。
什么是分布式锁？
apwf
09-03 1万+
分布式锁的概念 分布式锁其实可以理解为：控制分布式系统有序的去对共享资源进行操作，通过互斥来保持一致性。 举个例子：假设共享的资源就是一个房子，里面有各种书，分布式系统就是要进屋看书的人， 分布式锁就是保证这个房子只有一个门并且一次只有一个人可以进，而且门只有一把钥匙。 然后许多人要去看书，可以，排队，第一个人拿着钥匙把门打开进屋看书并且把门锁上， 然后第二个人没有钥匙，那就等着，等第一个出来，然后你在拿着钥匙进去，然后就是以此类推。 锁存在的意义 原因其实很简单：因为我们想让同一时刻只有一个线程在执行某段
详细剖析MySQL临键锁
緑水長流*z
07-17 1万+
临键锁（Next-Key Lock）：临键锁是查询时InnoDB根据查询的条件而锁定的一个范围，这个范围中包含有间隙锁和记录数；**临键锁=间隙锁+记录锁**。 其设计的目的是为了解决Phantom Problem(幻读)；主要是阻塞insert，但由于临键锁中包含有记录锁，因此临键锁所锁定的范围内如果包含有记录，那么也会给这些记录添加记录锁，从而造成阻塞除insert之外的操作； Tips：**临键锁的主要目的，也是为了避免幻读(Phantom Read)。如果把事务的隔离级别降级为RC，临键锁则也会失效
Redis实现分布式锁
Me_xuan的博客
04-26 6万+
基于Redis实现分布式锁，原理介绍，与zookeeper进行简单对比
广联达加密锁，写锁工具，可以自己升级加密锁。
06-23
加密锁在IT行业中，尤其是软件保护领域，是一种常见的技术手段，用于防止未经授权的软件复制和使用。广联达，作为中国领先的建筑信息化解决方案提供商，其加密锁产品是为确保其软件的安全性和正版化而设计的。这个...
Java锁的升级策略 偏向锁 轻量级锁 重量级锁
08-25
偏向锁的特点是：在第一次获得锁之后不会释放锁，它会一直持有锁，后续进入锁时只需检查一下锁状态和偏向线程ID是否为自己，从而省去了多次的加锁和解锁。偏向锁获取锁的过程是：检测对象头的Mark Word是否为可偏向...
支持10000同步锁，Spring Boot，Java
02-23
然而，synchronized锁有一些限制，比如它不提供公平性保证（即线程获取锁的顺序可能与它们请求锁的顺序不同），也不支持尝试获取锁、可中断锁等待以及定时锁等待等功能。这些限制可以通过使用ReentrantLock类来克服...
DHCP相关的实验报告
07-06
DHCP相关的实验报告
mmexport1720232414716.mp4
07-06
mmexport1720232414716.mp4
本文介绍了一种基于MATLAB的脉冲编码调制（PCM）通信系统仿真设计 PCM是一种广泛应用于数字通信系统中的信号编码技术，它通
最新发布
07-07
本文介绍了一种基于MATLAB的脉冲编码调制（PCM）通信系统仿真设计。PCM是一种广泛应用于数字通信系统中的信号编码技术，它通过将模拟信号转换为数字信号来实现信号的传输。本文首先介绍了PCM的基本原理，然后详细描述了基于MATLAB的PCM通信系统的设计与实现过程，包括信号的采样、量化、编码、传输和解码等关键步骤。通过仿真结果，验证了PCM通信系统的性能，并分析了系统在不同信噪比条件下的误码率。最后，本文总结了PCM通信系统在实际应用中的优势和局限性，并对未来的研究方向进行了展望。 关键词： 脉冲编码调制；MATLAB；数字通信；信号处理；仿真
10-1 Packet Tracer - HSRP Configuration Guide
07-06
10-1 Packet Tracer - HSRP Configuration Guide
concurrenthashmap锁
06-06
1. 分段锁：通过`Segment`类实现了细粒度的锁，确保并发性。 2. 内部结构：使用链地址法和开放寻址法（如再哈希）来处理哈希冲突，同时保证了读写操作的并行性。 3. CAS（Compare and Swap）操作：在底层实现原子性...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值