锁（八）

最新推荐文章于 2024-03-04 12:04:32 发布
最新推荐文章于 2024-03-04 12:04:32 发布
阅读量219 收藏
点赞数
分类专栏： 多线程 文章标签： ReebtrantLock ReentrantReadWriteLock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuduti/article/details/83780877
版权

锁

在java多线程中，我们知道使用synchronized关键字来实现线程间的同步互斥操作，那么其实还有一个更优秀的机制去完成“同步互斥”工作，它就是Lock对象，即重入锁和读写锁。他们具有比synchronized更为强大的功能，并且具有嗅探锁定、多路分支等功能。

ReentrantLock（重入锁）

  • 概念：
    在需要进行同步的代码部分加上锁定，但最后一定要释放锁，不然会造成锁用于无法释放，其他线程永远进不来的结果。
public class UseReentrantLock {

	final 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...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			lock.unlock();
		}
		
	}
	
	public void method2(){
		try {
			lock.lock();
			System.out.println(Thread.currentThread().getName() + "进入method2...");
			Thread.sleep(1000);
			System.out.println(Thread.currentThread().getName() + "退出method2...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		final UseReentrantLock url = new UseReentrantLock();
		
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				url.method1();
				url.method2();
			}
		},"t1");
		
		t1.start();
	}

}

/*
打印结果：
	t1进入method1...
	t1退出method1...
	t1进入method2...
	t1退出method2...
*/

锁与等待/通知

我们在使用synchronized的时候，如果需要多线程间进行协作工作则需要Object的wait()和notify()、notifyAll方法配合使用。同样，我们在使用Lock的时候，可以使用一个新的等待/通知的类Condition，这个Condition一定是针对具体的某一把锁，也就是在只有锁的基础之上才会产生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() + "进入等待状态...method1...");
			Thread.sleep(1000);
			System.out.println(Thread.currentThread().getName() + "释放锁...");
			condition.await(); //await 释放锁
			System.out.println(Thread.currentThread().getName() + "继续执行...method1...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			lock.unlock();
		}
		
	}
	
	public void method2(){
		try {
			lock.lock();
			System.out.println(Thread.currentThread().getName() + "进入method2...");
			Thread.sleep(3000);
			System.out.println(Thread.currentThread().getName() + "发出唤醒...");
			condition.signal(); //notify 不释放锁
			System.out.println(Thread.currentThread().getName() + "不释放锁...");
			System.out.println(Thread.currentThread().getName() + "执行完毕...method2...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			lock.unlock();
		}
	}
	
	public static void main(String[] args) throws InterruptedException {
		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();
		Thread.sleep(1000);
		t2.start();

	}
}
/*
打印结果:
	t1释放锁...
	t2进入method2...
	t2发出唤醒...
	t2不释放锁...
	t2执行完毕...method2...
	t1继续执行...method1...
*/

多个Condition

可以通过一个Lock对象产生多个Condition进行线程间的交互，非常的灵活。可以使得部分需要唤醒的线程唤醒，其他的线程则继续等待通知。

public class UseManyCondition {

	private Lock lock = new ReentrantLock();
	
	private Condition c1 = lock.newCondition();
	
	private Condition c2 = lock.newCondition();
	
	public void method1(){
		
		try {
			lock.lock();
			System.out.println(Thread.currentThread().getName() + "进入method1...");
			Thread.sleep(1000);
			c1.await();
			System.out.println(Thread.currentThread().getName() + "退出method1...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			lock.unlock();
		}
	}
	
	public void method2(){
		try {
			lock.lock();
			System.out.println(Thread.currentThread().getName() + "进入method2...");
			Thread.sleep(1000);
			c1.await();
			System.out.println(Thread.currentThread().getName() + "退出method2...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			lock.unlock();
		}
	}
	
	public void method3(){
		try {
			lock.lock();
			System.out.println(Thread.currentThread().getName() + "进入method3...");
			Thread.sleep(1000);
			c2.await();
			System.out.println(Thread.currentThread().getName() + "退出method3...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			lock.unlock();
		}
	}
	
	public void method4(){
		try {
			lock.lock();
			System.out.println(Thread.currentThread().getName() + "进入method4...");
			c1.signalAll();
			System.out.println(Thread.currentThread().getName() + "c1释放锁...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			lock.unlock();
		}
	}
	
	public void method5(){
		try {
			lock.lock();
			System.out.println(Thread.currentThread().getName() + "进入method5...");
			c2.signal();
			System.out.println(Thread.currentThread().getName() + "c2释放锁...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			lock.unlock();
		}
	}
	
	public static void main(String[] args) throws InterruptedException {
		final UseManyCondition umc = new UseManyCondition();
		
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				umc.method1();
			}},"t1");
		
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() {
				umc.method2();
			}},"t2");
		
		Thread t3 = new Thread(new Runnable(){
			@Override
			public void run() {
				umc.method3();
			}},"t3");
		
		Thread t4 = new Thread(new Runnable(){
			@Override
			public void run() {
				umc.method4();
			}},"t4");
		
		Thread t5 = new Thread(new Runnable(){
			@Override
			public void run() {
				umc.method5();
			}},"t5");
		
		t1.start();
		t2.start();
		t3.start();
		
		Thread.sleep(1000);
		
		t4.start();
		t5.start();
	}

}
/*
打印结果：
t1进入method1...
t3进入method3...
t2进入method2...
t4进入method4...
t4c1释放锁...
t5进入method5...
t5c2释放锁...
t1退出method1...
t2退出method2...
t3退出method3...
*/

Lock/Condition其他用法

公平锁和非公平锁：ReentrantLock lock = new ReentrantLock(boolean isFair),lock用法：

  • lock.tryLock()：
    尝试获得锁，获得结果用true/false返回。
  • lock.tryLock(paramLong, paramTimeUnit)：
    在给定的时间内尝试获得锁，获得结果用true/false返回。
  • lock.isFair()：
    是否公平锁。
  • lock.isLocked()：
    是否锁定。
  • lock.getHoldCount()：
    查询当前线程保持此锁的个数，也就是调用lock()次数。
  • lock.lockInterruptibly()：
    优先响应中断的锁。
  • lock.getQueueLength()：
    返回正在等待获取此锁的线程数。
  • lock.getWaitQueueLength(Condition paramCondition)：
    返回等待与锁定相关的给定条件Condition的线程数。
  • lock.hasQueuedThread(Thread paramThread)：
    查询指定的线程是否正在等待此锁。
  • lock.hasQueuedThreads()：
    查询是否有线程正在等待此锁。
  • lock.hasWaiters(Condition paramCondition)：
    查询是否有线程正在等待与此锁定有关的condition条件。

ReentrantReadWriteLock（读写锁）

读写锁，其核心就是实现读写分离。在高并发访问下，尤其是读多写少的情况下，性能要员高于重入锁。对于synchronized、ReentrantLock，我们知道，同一时间内，只能有一个线程进行访问被锁定的代码。读写锁则不同，其本质是分成两个锁，即读锁和写锁。在读锁下，多个线程可以并发的进行访问，但是在写锁的时候，只能一个一个顺序访问，即读读共享，写写互斥，读写互斥。

public class UseReentrantReadWriteLock {

	private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
	private ReadLock readLock = lock.readLock();
	private WriteLock writeLock = lock.writeLock();
	
	public void read(){
		try {
			readLock.lock();
			System.out.println(Thread.currentThread().getName() + "进入read...");
			Thread.sleep(1000);
			System.out.println(Thread.currentThread().getName() + "退出read...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			readLock.unlock();
		}
	}
	
	public void write(){
		try {
			writeLock.lock();
			System.out.println(Thread.currentThread().getName() + "进入write...");
			Thread.sleep(1000);
			System.out.println(Thread.currentThread().getName() + "退出write...");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			writeLock.unlock();
		}
	}
	
	public static void main(String[] args) {
		final UseReentrantReadWriteLock urrwl = new UseReentrantReadWriteLock();
		
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				urrwl.read();
			}},"t1");
		
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() {
				urrwl.read();
			}},"t2");
		
		Thread t3 = new Thread(new Runnable(){
			@Override
			public void run() {
				urrwl.write();
			}},"t3");
		
		Thread t4 = new Thread(new Runnable(){
			@Override
			public void run() {
				urrwl.write();
			}},"t4");
		
		//读读共享
		t1.start();
		t2.start();
		
		//读写互斥
		t1.start();
		t3.start();
		
		//写写互斥
		t3.start();
		t4.start();
	}

}
/*
打印结果：
t1进入read...
t2进入read...
t2退出read...
t1退出read...
t3进入write...
t3退出write...
 * */

锁优化

  1. 避免死锁。
  2. 减小锁持有时间。
  3. 减小锁的粒度。
  4. 锁的分离。
  5. 尽量使用无锁的操作，如原子操作（Atomic系列类），volatile关键字。
做最专注的自己
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
8锁问题
weixin_43912697的博客
03-01 102
8锁问题：关于锁的8个问题 public class demo01 { public static void main(String[] args) { Phone1 phone = new Phone1(); new Thread(()->{ phone.send(); },"A").start(); // 延时2秒 try { TimeUnit.SECONDS
线程第六课(附加)——八锁问题
Geek
11-28 391
  搞懂以下八个问题，同步锁就算真的搞懂了。   1 标准访问，先打印短信还是邮件   public class Lock_8 {     public static void main(String[] args) throws InterruptedException {         Phone phone1 = new Phone();         Phone ...
多线程8锁
weixin_42198596的博客
01-07 112
标准访问，请问先打印邮件还是短信？ 邮件方法暂停4秒钟，请问先打的邮件还是短信？ 新增一个普通方法hello（），请问先打印邮件还是hello？ 两部手机，请问先打印邮件还是短信？ 两个静态同步方法，同一部手机，请间先打印邮件还是短信？ 两个静态同步方法，2部手机，请问先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，1部手机，请间先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，2部手机，请问先打印邮件还是短信？ ...
java8锁问题
weixin_45664397的博客
05-17 188
经典八锁问题 1、synchronized标准访问 /** * @author alex tse * 8锁问题 * 1、标准访问，先发短信还是先打电话 */ public class test1 { public static void main(String[] args) { phone phone = new phone(); new Thread(()->{ phone.sendSMS(); //线程A执行发短信
四位数密码锁multisim仿真源文件
11-23
在密码锁设计中，这八个输入可能代表16进制的0到F，对应四位密码的每一个位。当用户输入密码时，这些信号通过逻辑门电路传递给74LS147，控制端的设置使得只有当输入的四位密码与预设的密码匹配时，特定的输出才被...
八位数字密码锁
12-30
基于multisim的八位开关数字密码锁,可以重新设置密码
电子密码锁申报书
12-28
3. **输出八段显示电路**：用于显示密码输入状态和错误提示，如果连续输入错误超过3次，系统会触发蜂鸣器报警并锁定键盘，防止恶意尝试。 设计过程中，学生需要完成的工作包括系统整体设计、选择合适的硬件元件、...
人体八把半锁”与仙家开锁方法.doc
09-29
人体八把半锁”与仙家开锁方法.doc
第二十八章-锁1
08-04
【第二十八章-锁1】本章探讨的是多线程环境下使用锁机制的问题。锁是一种同步原语，用于确保在并发执行中对共享资源的访问是互斥的，即同一时刻只有一个线程能够访问特定区域的代码或数据。在本案例中，我们将分析一...
八锁问题详解
strandtrack的博客
06-01 261
就是关于锁的八个问题 package sort; import java.util.concurrent.TimeUnit; /*** * 8锁，就是关于锁的8个问题 * * 1、标准情况下，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话 * 2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话 */ public class Test1 { public static void main(String[] args) { ...
关于8锁问题详细介绍
CP-Objeck的博客
05-18 1511
关于8锁问题 1、两个同步方法，一个对象调用。乌龟先跑？还是兔子先跑？ 答：乌龟先跑 /** * @Description: * @Package: com.cp.lock8 * @ClassName: Lock2 * @Author: cp * @Date: 2020/5/18 21:50 * @Version: 1.0 */ public class Lock1 { public static void main(String[] args) { Animal1
8锁问题，面试必懂知识
细数长流
11-15 166
最近听到一些人问说8锁是什么，这里简单的用代码解释一下。 1、是先打电话还是先发短信？ 2、电话方法内停4秒，是先打电话还是发短信？ 3、新增普通方法充电，是先打电话还是先充电？ 4、现在有两部手机，先打电话还是先发短信？ 5、现在打电话和发短信变成静态同步方法，一部手机，是先打电话还是先发短信？ 6、现在打电话和发短信变成静态同步方法，两部手机，是先打电话还是先发短信？ 7、一个静态同步方法，一个普通同步方法，一部手机，是先打电话还是先发短信？ 8、一个静态同步方法，一个普通同步方法，两部手机，是先打电话
JUC-多线程锁
weixin_30922589的博客
08-27 166
多线程锁的练习题 1、标准访问，先打印短信还是邮件 class Phone { public synchronized void sendSMS() throws Exception { Thread.sleep(400);题【2】添加延时 System. out .println( "------se...
8锁问题，探究锁到底锁了谁，谁被锁了
qq_42388853的博客
12-25 358
8锁就是8个锁的问题，直接探究出到底锁的是谁：下面看题和结果就可以了。 题的情况很简单，就是一个Phone类，里面有打电话和发短信俩方法，答案就是先发短信还是先打电话即可： 问题1：正常情况下，谁会先输出出来 package lock8; import java.util.concurrent.TimeUnit; //1、正常情况下，谁会先输出出来 public class Test1 { public static void main(String[] args) { Phone
经典8锁问题--助你彻底搞懂锁的概念
最新发布
weixin_42290025的博客
03-04 358
一个被static+synchronized 修饰的方法和普通的synchronized方法，先执行sendEmail()还是callPhone()？* 同被static+synchronized 修饰的两个方法，是先sendEmail()还是callPhone()?* 被synchronized 修饰的普通方法和静态方法 是先sendEmail() 还是 callPhone()?* 被synchronized 修饰的方式和普通方法 先执行sendEmail() 还是 callPhone()
8锁问题示例-通俗易懂
weixin_45216009的博客
06-16 361
synchronized：互斥锁： 分为 静态互斥锁，非静态互斥锁。在一个类中用 synchronized 修饰两个方法，然后实例化当前类(一个对象)， 对象调用当前类中两个方法，两方法执行顺序？锁谁？锁的对象：就是方法的调用者(实例化对象)；两个方法用的是同一把锁，先拿到先执行。(取决于CPU的调度)错误解释：而不是对象先调用哪个方法就先执行。在一个类中用 synchronized 修饰一个方法(设置延迟4s)，一个普通方法，然后实例化当前类(一个对象)， 对象调用当前类中两个方法，两方法执行顺序？普通方
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值