【多线程】ReentrantLock重入锁

最新推荐文章于 2023-06-05 13:27:01 发布
最新推荐文章于 2023-06-05 13:27:01 发布
阅读量486 收藏 1
点赞数
分类专栏： 多线程 并发编程线程 Java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26545305/article/details/79193882
版权

一、Lock接口

       在java多线程中，可以使用synchronized关键字来实现线程之间同步互斥、但在JDK1.5之后并发包中新增加了Lock接口（以及相关实现类）用来实现锁功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需要显示地获取和释放锁，虽然它缺少了隐式获取释放锁的便捷性，但是却拥有了锁获取与释放的可操作性、可中断的获取或及超时获取锁等多种synchronized关键字锁不具备的同步特性。

       synchronized关键字会隐式获取锁，但是它把锁的获取和释放固化了，也就是先获取再使用。不可否认的是这种方式简化了同步的管理，可以扩展性没有显示的锁获取和释放来的好。

       1、Lock接口提供的synchronized关键字不具备的主要特性

       

       2、Lock的API

      



 

二、使用ReentrantLock实现同步

      

public class MyService {
	private Lock lock=new ReentrantLock();
	public void testMethod(){
		//调用ReentrantLock对象的lock方法获取锁，调用unlock方法释放锁
		lock.lock();
		for (int i = 0; i < 5; i++) {
			System.out.println("ThreadName="+Thread.currentThread().getName()+(" "+(i+1)));
		}
		lock.unlock();
	}

}
     
public class MyThread extends Thread {
	private MyService service;
	public MyThread(MyService service){
		super();
		this.service=service;
	}
	@Override
	public void run(){
		service.testMethod();
	}

}
     
public class Run {
	public static void main(String[] args) {
		MyService service=new MyService();
		MyThread a1=new MyThread(service);
		a1.setName("a1");
		MyThread a2=new MyThread(service);
		a2.setName("a2");
		MyThread a3=new MyThread(service);
		a3.setName("a3");
		MyThread a4=new MyThread(service);
		a4.setName("a4");
		MyThread a5=new MyThread(service);
		a5.setName("a5");
		
		a1.start();
		a2.start();
		a3.start();
		a4.start();
		a5.start();
	}

}
     从运行的结果来看，当前线程打印完毕之后将锁进行释放，其他线程才可以继续打印。线程打印的数据是分组打印，因为当前线程已经持有锁，但线程之间的顺序是随机的。

三、使用Condition实现等待/通知

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

       在使用notify方法进行通知时，被通知的线程是JVM随机选择的。但ReentrantLock+Condition可以实现“选择性通知”。

       synchronized就相当于整个Lock对象中只有一个单一的Conditon对象，所有线程都注册在它一个对象的身上。线程开始notifyAll时，需要通知所有Wait状态的线程，没有选择权。

1、使用Condition实现等待/通知错误用法与解决

public class MyService {
	private ReentrantLock lock=new ReentrantLock();
	private Condition condition=lock.newCondition();
	public void waitMethod(){
		try {
			//lock.lock();
			System.out.println("A");
			condition.await();
			System.out.println("B");
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
			System.out.println("锁被释放了");
		}
	}

}

public class MyThreadA extends Thread {
	private MyService myService;
	public MyThreadA(MyService myService){
		this.myService=myService;
	}
	@Override
	public void run(){
		myService.waitMethod();
	}
}
public class Run {

	public static void main(String[] args) {
		MyService myService =new MyService();
		MyThreadA a=new MyThreadA(myService);
		a.start();
		//在控制台只打印一个字母A，原因是调用了Condition对象的await方法，使当前执行任务的线程进入等待WAITING状态
	}

}
    
        报错的异常信息是监视器出错，解决的办法是必须在condition.await方法之前调用lock.lock()代码获得同步监视器。将

lock.lock();的代码解注。最终在控制台中只打印了一个字母A，原因是调用了Condition对象的await方法。使当前线程进入了wait状态。

2、正确使用Condition实现等待/通知

      

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) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void signal(){
		try {
			lock.lock();
			System.out.println("signal时间为"+System.currentTimeMillis());
			condition.signal();
		}finally{
			lock.unlock();
		}
	}

}
      
public class ThreadA extends Thread {
	private MyService service;
	public ThreadA(MyService service){
		super();
		this.service=service;
	}
	@Override
	public void run(){
		service.await();
	}
	public static void main(String[] args) throws InterruptedException {
		MyService service=new MyService();
		ThreadA a=new ThreadA(service);
		a.start();
		Thread.sleep(3000);
		service.signal();
	}

}
      
public class Run {

	public static void main(String[] args) throws InterruptedException {
		MyService service=new MyService();
		ThreadA a = new ThreadA(service);
		a.start();
		Thread.sleep(3000);
		service.signal();
	}

}

     程序运行结果如下图所示,成功实现了等待/通知模式.

     

       ①  Object类中的wait方法相当于Condition类中的await方法.

       ②  Object类中的wait(long timeout)方法相当于Condition类中的await(long time,TimeUnit unit)

       ③  Object类中的notify方法相当于Condition类中的signal方法.

       ④  Object类中的notifyAll方法相当于Condition类中的signalAll方法

 3、使用多个Condition实现通知部分线程:

     MyService:

public class MyService {
	private Lock lock=new ReentrantLock();
	//两个condition对象
	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) {
			e.printStackTrace();
		}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) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}	
	}
	
	public void signalAll_A(){
		try {
			lock.lock();
			System.out.println("  signalAll_A 时间为"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
			conditionA.signalAll();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public void signalAll_B(){
		try {
			lock.lock();
			System.out.println("  signalAll_B 时间为"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
			conditionA.signalAll();
		} catch (Exception e) {
			lock.unlock();
		}finally{
			lock.unlock();
		}
	}
	

}
      
public class ThreadA extends Thread {
	private MyService service;
	public ThreadA(MyService service){
		super();
		this.service=service;
	}
	@Override
	public void run(){
		service.awaitA();
	}
}
     
public class ThreadB extends Thread {
	private MyService service;
	public ThreadB(MyService service){
		super();
		this.service=service;
	}
	@Override
	public void run(){
		service.awaitB();
	}
}
      测试类:

     

public class Run {

	public static void main(String[] args) throws InterruptedException {
		MyService service=new MyService();
		ThreadA a=new ThreadA(service);
		a.setName("A");
		a.start();
		ThreadB b=new ThreadB(service);
		b.setName("B");
		b.start();
		ThreadA.sleep(3000);
		service.signalAll_A();
		//通过此实验可以得知，使用ReentrantLock对象可以唤醒指定种类的线程，这是控制部分线程行为的方便方式
	}

}
     

         程序运行后，只有线程A被唤醒了，这说明使用ReentrantLock+condition对象可以唤醒指定部分的线程，可以先对线程分组，然后再唤醒指定组中的线程。

四、公平锁与非公平锁

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

        

public class Service {
	private ReentrantLock lock;
	public Service(boolean isFair){
		super();
		lock=new ReentrantLock(isFair);
	}
	public void serviceMethod(){
		try {
			lock.lock();
			System.out.println("ThreadName= "+Thread.currentThread().getName()+"获得锁定");
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}

}
     公平锁：

      

public class RunFair {
	/**
	 * 打印的结果是基本呈有序的，这就是公平锁的特点
	 * @param args
	 */
	public static void main(String[] args) {
		final Service service=new Service(true);
		Runnable runnable=new Runnable() {
			
			@Override
			public void run() {
				System.out.println("☆线程"+Thread.currentThread().getName()+"运行了");
				service.serviceMethod();
				
			}
		};
		Thread[] threadArray=new Thread[10];
		for (int i = 0; i < 10; i++) {
			threadArray[i]=new Thread(runnable);
		}
		for (int i = 0; i < 10; i++) {
			threadArray[i].start();
		}
		
	}
}
     非公平锁：

      

public static void main(String[] args) {
		/**
		 * 非公平锁的运行结果基本上是乱序的，说明先start启动的线程不代表先获得锁
		 */
		final Service service=new Service(false);
		Runnable runnable=new Runnable() {
			
			@Override
			public void run() {
				System.out.println("☆线程"+Thread.currentThread().getName()+"运行了");
				service.serviceMethod();
			}
		};
		Thread[] threadArray=new Thread[10];
		for (int i = 0; i < 10; i++) {
			threadArray[i]=new Thread(runnable);
		}
		for (int i = 0; i < 10; i++) {
			threadArray[i].start();
		}
	}

}






      

        

           


       



        




     

        

        

       


LemmonTreelss
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
Java多线程 ReentrantLock互斥锁详解
08-25
主要介绍了Java多线程 ReentrantLock互斥锁详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
多线程(二) -- 管程(六) -- ReentrantLock详解
weixin_39724194的博客
07-16 745
概述： ReentrantLock，一个可重入的互斥锁，它具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。 基本使用： public class ReentrantLockTest1 { private Lock lock = new ReentrantLock(); public void test() { try { lock.lock(); for (int i =
Lock锁中ReentrantLock中Condition的使用
weixin_42169734的博客
05-24 785
Lock锁中ReentrantLock中Condition的使用
可重入锁ReentrantLock与Condition
karute的博客
07-22 1017
一、可重入锁ReentrantLock 可重入锁可以完全替代synchronized，与synchronized相比，ReentrantLock是显式操作，需要手动指定何时加锁，何时释放锁。 之所以称之为可重入锁，是因为一个线程可以连续两次获得同一把锁，例如： lock.lock(); lock.lock(); try{ i++; } finally{ lock.unlock(); ...
ReentrantLock源码
chinaherolts2008的博客
07-30 123
JUC 指java.util.concurrent包下,一系列关于并发的类,JUC就是包名的首字母 CAS 比较并交换,可以看另一篇文章 AQS 指主要利用CAS来实现的轻量级多线程同步机制,并且不会在CPU上出现上下文切换和调度的情况 自定义锁 如何在自己实现一个锁? 可以定义一个属性来判断当前是否有其线程在运行,如果正在运行那么其他线程需要等待 如何实现? 例如有两个线程T1和T2,都执行同一段代码 自定义两个方法 public void lock();..
ReentrantLock的使用
u011191463的专栏
03-14 213
//  用于重启时，保证FillAutoAllotFlowTaskLogQueueThread类中restartInit方法与run方法的执行顺序     private static final ReentrantLock initLock = new ReentrantLock();     /**      * 将工作流自动处理任务线程和填充消费队列线程加入到线程池
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
Java多线程并发的程序中使用互斥锁有synchronized和ReentrantLock两种方式,这里我们来详解Java多线程编程中互斥锁ReentrantLock类的用法:
Java多线程并发编程(互斥锁Reentrant Lock)
08-30
主要介绍了ReentrantLock 互斥锁，在同一时间只能被一个线程所占有，在被持有后并未释放之前，其他线程若想获得该锁只能等待或放弃,需要的朋友可以参考下
locks框架_ReentrantLock.pdf
08-09
解释为什么它被称为“可重入锁”，以及如何解决传统锁可能的问题。 ReentrantLock 的基本用法： 深入探讨如何使用 ReentrantLock 来保护共享资源。演示如何通过 lock 和 unlock 方法来实现线程的同步和互斥。 ...
详解java多线程的同步控制
01-20
目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ReadWriteLock倒计数器 CountDownLatch循环栅栏 CyclicBarrier信号量 Semaphore 线程安全 Thread Safety JMM JMM(Java Memory Model)是一种基于计算机内存...
.NET中锁6大处理方法 悲观乐观自己掌握
10-28
.NET中锁6大处理方法 悲观乐观自己掌握 本文介绍了处理.NET中锁的6种方法，首先我们讨论一下并发性问题，然后讨论处理乐观锁的3种方法，乐观锁不能从根源上解决并发问题，因此后面我们介绍了悲观锁，最后介绍隔离级别如何帮助我们实现悲观锁，每个隔离级别都列举了示例进行说明，使得概念更加清晰。 　　我们为什么需要锁? 　　在多用户环境中，在同一时间可能会有多个用户更新相同的记录，这就会产生冲突，这个就是著名的并发性问题。
Java并发编程之ReentrantLock
qq_42964601的博客
01-31 144
ReentrantLock 相对于 synchronized 它具备如下特点 可中断 可以设置超时时间 可以设置为公平锁 支持多个条件变量 与 synchronized 一样，都支持可重入 基本语法 可重入 可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁 如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住 输出 可打断 示例 输出 注意如果是不可中断模式，那么即使使用了 interrupt 也不会让等待中断 输出 锁超时 立刻失败
ReentrantLock可重入独占锁详解
m0_73311735的博客
06-05 437
位于包下，是Lock接口的实现类。基本用法与相似，都具备可重入互斥的特性，但拥有更强大的且灵活的锁机制。class X {//定义锁对象// ...//定义需要保证线程安全的方法//加锁try{// 保证线程安全的代码// 使用finally块保证释放锁finally {API层面的独占锁：ReentrantLock是底层使用AQS实现的可重入的独占锁，区别于synchronized原生语法层面实现锁语义，ReetrantLock通过lock()和unlock()
多线程—ReentrantLock
qq_42251944的博客
10-21 572
你可能觉得很陌生，那我就把它和synchronized比较一下！ 与synchronized区别： 不同点： 可中断，运行代码块时，可以中断。 可以设置超时时间，例如：等待一段时间之后，还没有获取到锁，那么就放弃等待，去执行其他的任务代码。 可以设置为公平锁，可以防止线程饥饿。 支持多个条件变量，相当于有多个WaitSet等待队列，根据等待条件的不同而区分。 相同点： 都支持可重入 基本用法： //创建一个ReentrantLock对象 Reentr
ReentrantLock 锁详解
m0_37235955的博客
04-27 3056
ReentrantLock 支持公平锁和非公平锁，可重入锁 ReentrantLock的底层是通过 **AQS[链接]**实现。 一、BAT 大厂的面试题 **【1】**什么是可重入，什么是可重入锁? 它用来解决什么问题? 【2】ReentrantLock 的核心是 AQS，那么它怎么来实现的，继承吗? 说说其类内部结构关系。 【3】ReentrantLock 是如何实现公平锁的? 【4】ReentrantLock 是如何实现非公平锁的? 【5】ReentrantLock 默认实现的是公平还是非公平锁.
ReentrantLock
a2231476020的博客
12-19 167
在介绍AQS中，我们自定义了一个基于AQS的简单的锁，并实现了基本功能，其实JUC包的其他很多锁，都是通过类似的方式去实现了，不过功能更强大而已。下面具体的看一下ReentrantLock是怎么实现的，首先看一下它的内部类 可以看到它有三个内部类：抽象内部类Sync，其他两个内部类：FairSync和NonfairSync分别继承了该抽象类，毫无疑问抽象类Sync必定是继承了AbstractQu...
【面试：并发篇22多线程：ReentrantLock】
m0_71229547的博客
07-23 278
RennttrantLock也是锁和synchronized一样具有锁定同步代码块的作用，不过和synchronized还是有很多不一样的地方。RennttrantLock是下的一个类，相对于synchronized它具备如下特点1.可以打断处于BLOCKED状态的其他线程2.可以设置处于BLOCKED状态的线程超时时间，如果超过这个时间就放弃争抢锁3.可以设置为公平锁，线程按照先入先出获取锁。...
Java多线程--ReentrantLock的用法和原理
IT利刃出鞘的博客
11-08 3709
本文介绍Java的JUC中的ReentrantLock（可重入独占式锁）。包括：用法、原理。
C#锁的使用(lock,Monitor,Mutex,ReaderWriterLockSlim )
xiaokaiv587的博客
08-09 2168
C#中lock,Monitor,Mutex,ReaderWriterLockSlim这几种锁你都会使用了吗？
ReentrantLock是可重入锁吗
最新发布
02-23
是的，ReentrantLock是可重入锁。可重入锁是指同一个线程可以多次获取同一个锁而不会造成死锁。ReentrantLock内部维护了一个计数器，当一个线程第一次获取锁时，计数器加1，当该线程再次获取锁时，计数器再次加1。只有当计数器归零时，其他线程才能获取该锁。这种机制保证了同一个线程可以多次获取锁而不会造成死锁。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值