多线程lock的使用，ReentrantLock，Condition 实现等待/通知，公平锁与非公平锁

最新推荐文章于 2023-07-15 15:05:10 发布
最新推荐文章于 2023-07-15 15:05:10 发布
阅读量309 收藏
点赞数
分类专栏： 多线程基础 文章标签： 公平锁与非公平锁 lock ReentrantLock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45206831/article/details/98853923
版权

一、使用ReentrantLock 类

在Java多线程中，可以使用synchronized 关键字来实现线程之间的同步互斥，但在JDK1.5 中新增了 ReentrantLock 类也能达到同样的效果，并且在扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知等功能，而且在使用上也比synchronized更加的灵活。

1.使用ReentrantLock 实现同步

同步的方法所在类：

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

public class MyService {
	private Lock lock = new ReentrantLock();
	public void methodA(){
		try {
			lock.lock();
			System.out.println("methodA begin ThreadName = "+ Thread.currentThread().getName()+" begin time "+System.currentTimeMillis());
			Thread.sleep(2000);
			System.out.println("methodA end ThreadName = "+ Thread.currentThread().getName()+" end time "+System.currentTimeMillis());
		} catch (Exception e) {
		}finally{
			lock.unlock();
		}
	}
	public void methodB(){
		try {
			lock.lock();
			System.out.println("methodB begin ThreadName = "+ Thread.currentThread().getName()+" begin time "+System.currentTimeMillis());
			Thread.sleep(2000);
			System.out.println("methodB end ThreadName = "+ Thread.currentThread().getName()+" end time "+System.currentTimeMillis());
		} catch (Exception e) {
		}finally{
			lock.unlock();
		}
	}
}

两个线程类ThreadA 与 ThreadB：


    public class ThreadA extends Thread{
	
	private MyService service;
	public ThreadA(MyService service){
		this.service = service;
	}
	@Override
	public void run() {
		service.methodA();
	}
}


public class ThreadB extends Thread{
	
	private MyService service;
	public ThreadB(MyService service){
		this.service = service;
	}
	@Override
	public void run() {
		service.methodB();
	}
}

测试入口：

public class Run {
	public static void main(String[] args){
		MyService service = new MyService();
		ThreadA a = new ThreadA(service);
		a.setName("A");
		a.start();
		ThreadB b = new ThreadB(service);
		b.setName("B");
		b.start();
	}
}

运行结果：
在这里插入图片描述
从运行结果上看，当前线程打印完，将锁进行释放，其他线程才可以继续打印。调用lock.lock()代码的线程就持有了“对象监视器”其他线程只有等待锁被释放时再次争抢。效果和使用synchronized关键字一样，县城建史顺序执行的。

2.使用Condition 实现等待/通知

关键字synchronized 与wait()和notify()/notifyAll()方法结合可以实现等待/通知模式。借助Condition对象，类ReentrantLock 也可以实现同样的功能。Condition 类是 JDK5 中出现的技术，使用它有更好的灵活性，比如可以实现多路通知功能，也就是在一个Lock 对象里面可以创建多个Condition实例，线程对象可以注册在指定的Condition 中，从而可以有选择性地进行线程通知，在调度线程上更加灵活。
代码如下：

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

public class MyService {
	private Lock lock = new ReentrantLock();
	public Condition condition = lock.newCondition();
	public void await(){
		try {
			lock.lock();
			System.out.println("进入await的时间为"+System.currentTimeMillis());
			condition.await();
		} catch (Exception e) {
		}finally{
			lock.unlock();
		}
	}
	public void  signal(){
		try {
			lock.lock();
			System.out.println("进入signal的时间为"+System.currentTimeMillis());
			condition.signal();
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			lock.unlock();
		}
	}
}

public class ThreadA extends Thread{
	private MyService service;
	ThreadA(MyService service){
		this.service = service;
	}
	@Override
	public void run() {
		service.await();
	}
}

public class Run {
	public static void main(String[] args){
		try {
			MyService service = new MyService();
			ThreadA a = new ThreadA(service);
			a.start();
			Thread.sleep(2000);
			service.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

运行结果：
在这里插入图片描述
注意：在调用condition.await()方法之前需要调用lock.lock() 代码获得同步监视器。不然会报监视器出错的异常 java.lang.illegalMonitorStateException。

3.使用Condition 实现通知 特定的线程

代码如下：

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

public class MyService {
	private Lock lock = new ReentrantLock();
	public Condition conditionA = lock.newCondition();
	public Condition conditionB = lock.newCondition();
	public void awaitA(){
		try {
			lock.lock();
			System.out.println("begin awaitA时间为  " + System.currentTimeMillis() + " ThreadName= " +Thread.currentThread().getName());
			conditionA.await();
			System.out.println("end awaitA时间为  " + System.currentTimeMillis() + " ThreadName= " +Thread.currentThread().getName());
		} catch (Exception e) {
		}finally{
			lock.unlock();
		}
	}
	public void awaitB(){
		try {
			lock.lock(); 
			System.out.println("begin awaitB时间为  " + System.currentTimeMillis() + " ThreadName= " +Thread.currentThread().getName());
			conditionB.await();
			System.out.println("end awaitB时间为  " + System.currentTimeMillis() + " ThreadName= " +Thread.currentThread().getName());
		} catch (Exception e) {
		}finally{
			lock.unlock();
		}
	}
	public void signalAll_A(){
		try {
			lock.lock();
			System.out.println("signal_A时间为  " + System.currentTimeMillis() + " ThreadName= " +Thread.currentThread().getName());
			conditionA.signalAll();
		} catch (Exception e) {
		}finally{
			lock.unlock();
		}
	}
	public void signalAll_B(){
		try {
			lock.lock();
			System.out.println("signal_B时间为  " + System.currentTimeMillis() + " ThreadName= " +Thread.currentThread().getName());
			conditionB.signalAll();
		} catch (Exception e) {
		}finally{
			lock.unlock();
		}
	}
}

public class ThreadA extends Thread{
	private MyService service ;
	public ThreadA(MyService service){
		this.service = service;
	}
	@Override
	public void run() {
		service.awaitA();
	}
}

public class ThreadB extends Thread{
	private MyService service ;
	public ThreadB(MyService service){
		this.service = service;
	}
	@Override
	public void run() {
		service.awaitB();
	}
}

public class Run {
	public static void main(String[] args){
		try {
			MyService service = new MyService();
			ThreadA a = new ThreadA(service);
			a.setName("A");
			a.start();
			ThreadB b = new ThreadB(service);
			b.setName("B");
			b.start();
			Thread.sleep(3000);
			service.signalAll_A();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

运行结果：
在这里插入图片描述
通过运行结果 只有 A 线程被唤醒了，因此可以得知 使用 ReentrantLock 对象可以唤醒指定种类的线程，这是控制部分线程行为的方便方式。

4.公平锁与非公平锁

公平锁与非公平锁：锁Lock分为“公平锁”和“非公平锁”，公平锁表示线程获取所得顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序。而非公平锁就是一种获取锁的抢占机制，是随机获得锁的，和公平锁不一样的就是先来的不一定先得到锁，这个方式可能造成某些线程一直拿不到锁，结果也就是不公平的了。

5.常用的一些方法

1）getHoldCount()
方法 int getHoleCount()方法的作用是 查询当前线程保持此锁定的个数，也就是调用lock()方法的次数。

public class GetHoldCount {
	private ReentrantLock lock = new ReentrantLock();
	public void methodOne(){
		lock.lock();
		lock.lock();
		lock.lock();
		lock.lock();
		System.out.println("One 中 持锁数为"+lock.getHoldCount());
	}
}

public class GetHoldCountRun {
	public static void main(String[] args){
		GetHoldCount ghc = new GetHoldCount();
		ghc.methodOne();
	}
}

运行结果：
在这里插入图片描述
2）getQueueLength()
方法int getQueueLength()的作用是返回正等待获取此锁定的线程估计数，比如有5个线程，1个线程首先执行 await()方法，那么在调用getQueueLength()方法后返回值是4，说明4个线程同时等待lock的释放。

public class GetQueueLength {
	public ReentrantLock lock = new ReentrantLock();
	public void method(){
		try {
			lock.lock();
			System.out.println("ThreadName= "+Thread.currentThread().getName());
			Thread.sleep(Integer.MAX_VALUE);
		} catch (Exception e) {
		}finally {
			lock.unlock();
		}
	}
}

public class GetQueueLengthRun {
	public static void main(String[] args){
		final GetQueueLength gql = new GetQueueLength();
		Runnable runnable = new Runnable(){
			@Override
			public void run() {
				gql.method();
			}
		};
		Thread[] threadArr = new Thread[10];
		for(int i = 0; i< 10; i++){
			threadArr[i] = new Thread(runnable);
		}
		for(int i = 0;i<10;i++){
			threadArr[i].start();
		}
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("还有"+ gql.lock.getQueueLength());
	}
}

运行结果：
在这里插入图片描述
3）getWaitQueueLength(Condition condition)
方法 int getWaitQueueLength(Condition condition) 的作用是返回等待与此锁定相关的给定条件 Condition 的线程估计数，比如有5个线程，每个线程都执行了同一个condition对象的await()方法，则调用getWaitQueueLength(Condition condition)方法时返回的int 值是5。

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

public class GetWaitQueueLength {
	private ReentrantLock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	public void waitMethod(){
		try {
			lock.lock();
			condition.await();
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			lock.unlock();
		}
	}
	public void notityMethod(){
		try {
			lock.lock();
			System.out.println("有"+lock.getWaitQueueLength(condition));
			condition.signalAll();
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			lock.unlock();
		}
	}
}

public class GetWaitQueueLengthRun {
	public static void main(String[] args){
		final GetWaitQueueLength gwql = new GetWaitQueueLength();
		Runnable runnable = new Runnable(){
			@Override
			public void run(){
				gwql.waitMethod();
			}
		};
		Thread[] threadArr = new Thread[10];
		for(int i = 0;i<10;i++){
			threadArr[i] = new Thread(runnable);
		}
		for(int i=0;i<10;i++){
			threadArr[i].start();
		}
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		gwql.notityMethod();
	}
}

运行结果：
在这里插入图片描述
4）hasQueuedThread(Thread thread)与hasQueuedThreads()
hasQueuedThread(Thread thread)的作用是查询指定的线程是否正在等待获取此锁定。
hasQueuedThreads()的作用 是查询是否有线程正在等待获取此锁定。

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

public class HasQueuedThread {
	public ReentrantLock lock = new ReentrantLock();
	public Condition condition = lock.newCondition();
	public void waitMethod(){
		try {
			lock.lock();
			Thread.sleep(Integer.MAX_VALUE);
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			lock.unlock();
		}
	}
}

public class HasQueuedThreadRun {
	public static void main(String[] args) throws InterruptedException{
		final HasQueuedThread hqt = new HasQueuedThread();
		Runnable runnable = new Runnable(){
			@Override
			public void run(){
				hqt.waitMethod();
			}
		};
		Thread a = new Thread(runnable);
		a.start();
		Thread.sleep(500);
		Thread b = new Thread(runnable);
		b.start();
		Thread.sleep(500);
		System.out.println(hqt.lock.hasQueuedThread(a));
		System.out.println(hqt.lock.hasQueuedThread(b));
		System.out.println(hqt.lock.hasQueuedThreads());
	}
}

5） hasWaiters(Condition condition)
方法 boolean hasWaiters(Condition condition)的作用是 查询是否有线程正在等待与此锁定有关的condition条件。

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

public class HasWaiters {
	private ReentrantLock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	public void waitMethod(){
		try {
			lock.lock();
			condition.await();
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			lock.unlock();
		}
	}
	public void notityMethod(){
		try {
			lock.lock();
			System.out.println("有没有线程正在等待 condition？ "+lock.hasWaiters(condition)+"线程数是多少？ "+lock.getWaitQueueLength(condition));
			condition.signalAll();
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			lock.unlock();
		}
	}
}

public class HasWaiterRun {
	public static void main(String[] args){
		final HasWaiters hw = new HasWaiters();
		Runnable runnable = new Runnable(){
			@Override
			public void run(){
				hw.waitMethod();
			}
		};
		Thread[] threadArr = new Thread[10];
		for(int i = 0;i<10;i++){
			threadArr[i] = new Thread(runnable);
		}
		for(int i=0;i<10;i++){
			threadArr[i].start();
		}
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		hw.notityMethod();
	}
}

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

脚踏大地走不停歇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程中ReentrantLock与Condition详解
08-28
主要介绍了Java多线程中ReentrantLock与Condition详解,需要的朋友可以参考下
使用Lock锁实现等待唤醒机制
at10090的博客
02-01 1245
在使用Lock进行解决线程同步问题时,会存在使用Object的wait()和sleep()方法异常的问题. 而jdk也提供了Condition对应于Objcet的wait(),notify()和notifyAll()方法提供了await(),siganl()和signalAll()方法. Condition实例实质上是需要绑定到一个锁上.所以需要为Lock实例获得Condition实例,需要使用......
线程安全（二）Lock 什么是Lock线程锁？与synchronized区别在哪？Lock锁是如何实现等待通知的？如何实现线程顺序执行？
热门推荐
T_Antry
01-31 2万+
一.synchronized的缺陷 二.Lock接口的特性 三.Lock接口基本的方法： 四、Lock接口的实现类：ReentrantLock 五、ReadWriteLock 六、Condition接口 简介 Condition接口的常见方法： . 使用单个Condition实例实现等待/通知机制： 使用多个Condition实例实现等待/通知机制： 使用Condition实现顺序执行 七、ReentrantReadWriteLock 八、公平锁与非公平锁 九、可重入锁
分布式锁实现
张姐姐聊编程
03-07 1013
控制分布式系统或不同系统之间共同访问共享资源的一种锁实现，如果不同的系统或同一个系统的不同主机之间共享了某个资源时，需要互斥来防止彼此干扰来保证一致性
操作系统__锁（Lock）的几种简单实现方式
AlexanderGan的博客
05-22 3612
操作系统__锁（Lock）的几种简单实现方式 （1）无锁访问共享资源带来的问题 阅读上面的代码可以预计，g_count的预期输出结果是2000，下面我们看看实际的结果： 实际运行结果中间出现了1057， 说明对于共享资源的并发访问会导致结果与预期不一致，这是为什么呢？ 实际上g_count = g_count + 1 这个操作并不是原子操作。 上图解释了为什么会出现这种情况，两个线程都各自执行完了一次循环，我们设想g_count的值会加2，但是实际上只加了1，所以会导致我们看到./lockTest的执
分布式锁及实现方式
王文萱的博客
07-03 617
分布式锁及实现方式
JUC知识点总结（三）ReentrantLock与ReentrantReadWriteLock源码解析
01-21
8. Lock接口 （ReentrantLock 可重入锁） 特性 ReentantLock 继承接口 Lock 并实现了接口中定义的方法， 它是一种可重入锁， 除了能完成 synchronized 所能完成的所有工作外，还提供了诸如可响应中断锁、可轮询锁...
Lock锁的底层原理完整版
11-21
此外，Lock接口还有一个带条件的锁——Condition接口的实现类ReentrantLock。这种带条件的锁使得线程可以在一定条件下挂起等待，直到其它线程唤醒它。 在实际使用场景中，例如多个用户同时操作一个银行账户的情况，...
【2018最新最详细】并发多线程教程
11-15
12.详解Condition的await和signal等待通知机制 13.LockSupport工具 14.并发容器之ConcurrentHashMap(JDK 1.8版本) 15.并发容器之ConcurrentLinkedQueue 16.并发容器之CopyOnWriteArrayList 17.并发容器之ThreadLocal...
汪文君高并发编程实战视频资源全集
08-08
 高并发编程第三阶段30讲 使用Condition实现一个多线程下的Producer-Consumer_.mp4  高并发编程第三阶段31讲 JDK8-StampedLock详细介绍-上_.mp4  高并发编程第三阶段32讲 JDK8-StampedLock详细介绍-下.mp4  高...
Java并发编程(10) —— ReentrantLock类详解
m0_56602092的博客
07-15 643
一、ReentrantLock介绍 ReentrantLock是juc.locks包中的一个独占式可重入锁，相比synchronized，它可以创建多个条件等待队列，还支持公平/非公平锁、可中断、超时、轮询等特性。 ReentrantLock实现Lock接口实现了一个锁所需的方法，如lock()、unLock()等，在这些方法中实际上是调用继承了AQS的同步器Sync对象中的方法来实现对锁资源的获取与释放，而内部类Sync有两个子类FairSync和NonfairSync，分别对应公平锁和非公平锁。Ree
多线程（6）等待唤醒机制Lock，condition
Luther的博客
05-26 407
从JDK1.5 之后，提供新的等待唤醒机制Lock 之前用的wait（），notify（），notifyAll（），都是在JDK1.5之前使用， 不同的线程在锁住同一个对象后，调用wait（）线程等待，notifyAll（）唤醒所有的线程池里的线程，但是通常我们不需要唤醒所有的线程，只唤醒我们需要的线程即可，JDK1.5后提供Lock 接口。 上一个列子，做了下修改。 new Reentr
并发(四)：ReentrantLock之条件等待队列
qq_37805943的博客
06-21 488
详细文案可以看下链接, 关注一波, 后期分享经典面试题并发(四)：ReentrantLock之条件等待队列并发(四)：ReentrantLock之条件等待队列并发(四)：ReentrantLock之条件等待队列并发(四)：ReentrantLock之条件等待队列并发(四)：ReentrantLock之条件等待队列条件等待队列 在并发(三)：ReentrantLock类中，谈到了锁，每个ReentrantLock锁对应很多个条件等待队列，而synchronized锁只存在一个条件等待队列。 //图中的Reen
ReentrantLock原理
weixin_39082432的博客
03-02 501
ReentrantLock，顾名思义，可重入锁 首先看下源码 实现了Lock类，先基本看下Lock类 lock：获取锁，锁被其他线程占用，那么会等待，直到获取锁 lockInterruptibly：获取锁，但是假如当前线程在等待锁的时候被中断，抛出中断异常 tryLock：尝试获取锁，并立即返回 tryLock：在一定时间范围类尝试获取锁 unLock：释放锁 newCondition：新建一个绑定在当前Lock上的Condition对象，condition表示一个等待状态，获得锁的线程
Java~多线程ReentrantLock的公平锁和非公平锁 ,结合Condition实现部分路通知和选择路通知
Shangxingya的博客
10-10 437
文章目录ReentrantLock演示ReentrantLock的同步功能ReentrantLock的公平锁与非公平锁代码演示Condition对象监视器演示Condition的等待与通知实现部分路通知和选择路通知 ReentrantLock 在Java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中新增加了ReentrantLock类也能达到同样的效果，并且在扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知等功能，而且在使用上也比 synchronized更
类 ReentrantLock 使用（一）
weixin_37585619的博客
08-31 201
ReentrantLock学习
重入锁ReentrantLock+Condition 实现等待/通知
Morgan_Xiang的专栏
06-04 1073
        在Java多线程编程中，可以使用Synchronized来实现同步，可以synchronized类，方法或代码块，另外还可以使用ReentrantLock来实现同样的功能，而且功能更加强大。        1. 使用ReentrantLock实现同步public class ReentrantLockTest { private Lock lock = new Reent...
ReentrantLock（二）：正确使用Condition实现等待与通知
三叶初秋的博客
04-26 8424
关键字synchronized与wait()和notify()/notifyAll()方法相结合可以实现等待/通知模式。 类ReentrantLock同样可以实现该功能，但是要借助于Condition对象。它具有更好的灵活性，比如可以实现多路通知功能，也就是在一个Lock对象里面可以创建多个Condition(对象监视器)实例，线程对象可以注册在指定Condition中，从而有选择性的进行线程通知
Java多线程(五) ReentrantLock、Lock和Condition的用法
李金振的专栏
11-17 826
Java多线程(五) ReentrantLock、Lock和Condition的用法
java ReentrantLock使用方法
最新发布
03-09
Java中的ReentrantLock是一个可重入的互斥锁，它提供了与synchronized关键字相似的功能，但更加灵活和强大。下面是ReentrantLock的使用方法： 1. 创建ReentrantLock对象： ```java ReentrantLock lock = new ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值