ReentranLock 重入锁

最新推荐文章于 2022-08-24 15:51:58 发布
最新推荐文章于 2022-08-24 15:51:58 发布
阅读量222 收藏
点赞数
分类专栏： java 文章标签： ReentranLock  重入锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38982591/article/details/104260430
版权

重入锁可以完全替代关键字synchronize。在jdk5.0的早期版本中，重入锁的性能远超于关键字synchronize，但是在jdk6.0开始，jdk在关键字synchronize上做了大量的优化，似的两者间的差距并不是很大。

1.中断响应

对于关键字来说，如果一个线程在等待锁，那么结果只有两种情况，要么获得锁继续执行，要么保持等待。而使用重入锁，则提供了另外一种可能，就是线程可以中断。

代码示例：

package com.gpdi.operatingunit.test;


import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Lxq
 * @date 2020/2/11 11:44
 * @describtion
 **/
public class IntLock implements Runnable{

    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lock;

    /**
     * 加锁控制顺序，方便构成死锁
     * @param lock
     */
    public IntLock(int lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            if (lock == 1){
                lock1.lockInterruptibly();
                try {
                    Thread.sleep(500);
                }catch (InterruptedException e){}
                lock2.lockInterruptibly();
            }else {
                lock2.lockInterruptibly();
                try {
                    Thread.sleep(500);
                }catch (InterruptedException e){}
                lock1.lockInterruptibly();
            }

        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            // lock.isHeldByCurrentThread()的作用是查询当前线程是否保持此锁定
            if (lock1.isHeldByCurrentThread()){
                System.out.println("lock1" + lock1.isHeldByCurrentThread());
                lock1.unlock();
            }
            if (lock2.isHeldByCurrentThread()){
                System.out.println("lock2" + lock2.isHeldByCurrentThread());
                lock2.unlock();
            }
            System.out.println(Thread.currentThread() + "线程退出");
        }

    }

    public static void main(String[] args) throws InterruptedException {
        IntLock r1 = new IntLock(1);
        IntLock r2 = new IntLock(2);
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
        Thread.sleep(1000);
        t2.interrupt();
    }
}

java.lang.InterruptedException
	at java.base/java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:944)
	at java.base/java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1263)
	at java.base/java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:317)
	at com.gpdi.operatingunit.test.IntLock.run(IntLock.java:40)
	at java.base/java.lang.Thread.run(Thread.java:834)
lock2true
lock1true
lock2true
Thread[Thread-1,5,main]线程退出
Thread[Thread-0,5,main]线程退出

线程t1和线程t2启动后，t1先占用lock1，再占用lock2；t2先占用lock2，再请求lock1.因此形成了t1和t2之前互相等待，对锁的请求统一使用lockInterruptibly()，这是一个可以中断响应的锁申请动作，即再等待的过程中，可以响应中断。

再main线程 处于休眠状态，此时，两个线程都处于死锁的状态，当main 线程中t2线程中断，故t2放弃对lock1的申请，同时释放了lock2.这个操作导致t1的线程可以顺利得到lock2而继续执行下去。

2.锁申请等待限时

除了等待外部的通知之外，要避免死锁还用另外一种方法，就是限时等待。如果给定一个时间，让线程自动放弃，那么对于系统来说是有意义的，我们使用tryLock()方法进行一次限时等待。

代码示例：

package com.gpdi.operatingunit.test;

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

/**
 * @author Lxq
 * @date 2020/2/11 12:19
 * @describtion
 **/
public class TimeLock implements Runnable {

    public static ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            if (lock.tryLock(5, TimeUnit.SECONDS)){
                Thread.sleep(6000);
            }else {
                System.out.println("get lock failed");
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            if (lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        TimeLock lock = new TimeLock();
        Thread t1 = new Thread(lock);
        Thread t2 = new Thread(lock);
        t1.start();
        t2.start();
    }
}

get lock failed

tryLock 接受两个参数，一个表示等待时长，一个表示计时单位，这里的单位是秒，时长为5，表示线程在请求锁的最多时长为5秒，如果超过了5秒还没获取锁，就会返回false，如果成功获取锁，则返回true。

ReentrantLock.tryLock() 方法也可以不带参数直接运行。在这种情况下，当前线程会尝试获取锁，如果锁并未被其他线程占用，则申请锁成功，并返回true。如果锁被其他线程占用，则当前线程不会继续等待，而是立即放回false，这种模式下不会引起线程等待，因此也不会产生死锁。

代码示例：

package com.gpdi.operatingunit.test;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Lxq
 * @date 2020/2/11 12:34
 * @describtion
 **/
public class TryLock implements Runnable {

    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();

    int lock;

    public TryLock(int lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        if (lock == 1) {
            while (true) {
                try {
                    if (lock1.tryLock()) {
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if (lock2.tryLock()) {
                            try {
                                System.out.println(Thread.currentThread() + " my job done");
                                return;
                            }finally {
                                lock2.unlock();
                            }
                        }
                    }
                } finally {
                    lock1.unlock();
                }
            }
        }else {
            while (true) {
                try {
                    if (lock2.tryLock()) {
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if (lock1.tryLock()) {
                            try {
                                System.out.println(Thread.currentThread() + " my job done");
                                return;
                            }finally {
                                lock1.unlock();
                            }
                        }
                    }
                } finally {
                    lock2.unlock();
                }
            }
        }
    }

    public static void main(String[] args) {
        TryLock r1 = new TryLock(1);
        TryLock r2 = new TryLock(2);
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
    }
}

上面代码很容易产生死锁，但是使用了tryLock()方法后，这种情况就大大改善。由于线程不会傻傻等待，而是不停尝试，因此只要有足够长的时间，线程最终会获得所需要的资源，从而正常执行。

3.公平锁

大多数情况下，锁的申请都是非公平的。如果我们使用synchronize关键字进行控制的话，那么产生的锁就是非公平锁。而重入锁允许我们对其公平性进行设置。构造函数如下：

 public ReentrantLock(boolean fair) {
        this.sync = (ReentrantLock.Sync)(fair ? new ReentrantLock.FairSync() : new ReentrantLock.NonfairSync());
    }

 

当参数为fair为true时，表示锁时公平的。公平锁看起来很优美，但是要实现公平锁必然要维护一个有序的队列，因此公平锁实现的成本比较高，性能却非常低下，在默认的情况下，锁时非公平的。如果没有特殊的要求，则不要使用公平锁。

代码示例：

package com.gpdi.operatingunit.test;

import org.apache.poi.ss.formula.functions.T;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Lxq
 * @date 2020/2/11 12:58
 * @describtion
 **/
public class FairLock implements Runnable{
    public static ReentrantLock lock = new ReentrantLock(true);

    @Override
    public void run() {
        while (true){
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + " 获取锁");
            }finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        FairLock r1 = new FairLock();
        Thread t1 = new Thread(r1,"Thread_t1");
        Thread t2 = new Thread(r1,"Thread_t2");
        t1.start();
        t2.start();
    }
}

总结：

  • lock（）获取锁，如果锁被占用，则等待。
  • lockInterruptibly（）：获取锁，优先响应中断。
  • tryLock（）获取锁，如果成功，则返回true，失败返回false。该方法不等待，立即返回。
  • tryLock（long time,TimeUnit unit）给定时间内尝试获取锁。
  • unlock（）释放锁

 

 

 

 

 

 

 

 

yueF_L
关注
专栏目录
Java多线程并发的可重入锁ReentrantLock
seaboat——a free boat on the sea.（公众号：远洋号）
10-16 519
可重入锁 Java中的可重入锁（ReentrantLock）是用于控制并发的一种工具，它的功能类似于Java内置的Synchronized语法。可重入锁是指一个线程可以多次对某个锁进行加锁操作，比如程序在多层调用中多次使用锁。而对于不可重入锁来说，进行两次以及上的加锁会导致死锁的产生。 ReentrantLock是一种独占锁，在独占模式下线程只能逐一使用锁，即任意时刻仅仅只能有一条线程持有锁。如下图，线程一首先成功调用lock方法进行加锁操作从而持有该锁，其它两个线程只能等待线程一释放锁。因为锁是可重入的，
面试官：可重入锁（ReentrantLock）是轻量级锁（lightweight/thin lock）吗？
Ryanqy的专栏
04-06 4389
引言 我们都知道高效并发是从JDK5升级到JDK6后一项重要的改进型，HotSpot虚拟机开发团队在这个版本上花费了大量的资源去实现各种锁优化技术，如适应性自旋（Adaptive Spinning）、锁消除（Lock Elimination）、锁膨胀（Lock Coarsening）、轻量级锁（Lightweight/Thin Locking）、偏向锁（Biased Locking）等等，这些技术...
Lock重入锁
田培融的博客
05-06 480
前言 在并发编程中有两个核心问题， 一个是互斥另一个是同步。在java sdk并发包中，lock就是解决互斥问题，conditon就是解决同步问题。 Lock lock有三个重要的特性： 能够响应中断： 线程在没有获取锁的时候，进入阻塞状态。我们能够给进入阻塞状态的线程发送信号，重新唤醒它。 支持超时： 在无法获取锁的时候，就等待一定的时间。超时就自动返回。 非阻塞的获取锁：如果无法获取锁就马上...
重入锁
E_K_in的博客
01-10 369
只要线程已经获得某个对象的锁或者是获得了某个ReentrantLock锁，那么这个线程在未释放这个锁之前可以多次请求获取并能获得这个锁，因为锁有一个持有计数来跟踪获得锁的次数。比如，某个线程已经获得了一个锁(无论是对象锁还是ReentrantLock锁)，那么他就可以继续请求并能获取到这个锁，其获得X次锁，则这个锁的持有计数就为X,每获取一次锁，持有计数加1，每释放一次锁持有计数减1直到持有计数变
Lock锁＜二＞ _ 重入锁/读写锁
爱我所爱0505
04-12 634
目录 一、重入锁ReentrantLock 1. 实现锁重进入 2. 获取公平锁与非公平锁的区别 二、读写锁ReentrantReadWriteLock 1.ReentrantReadWriteLock的API 2. 读写状态设计 3. 写锁的获取与释放 4.读锁的获取与释放 5. 写锁降级 三、参考资料 一、重入锁ReentrantLock 重入锁指线程获得锁后能够再次获取该锁而线程不被阻塞。synchronized关键字隐式的支持重进入。java.util...
ReentrantLock 重入锁(互斥锁)
lm1060891265的博客
08-16 3391
参考博客：https://blog.csdn.net/jiangjiajian2008/article/details/52226189 Synchronized是依赖于JVM实现的，而ReenTrantLock是JDK实现的 与synchronized相比，重入锁有着显式的操作过程，开发人员必须手动的指定何时加锁（调用lock方法），何时释放锁（调用unlock方法）。因此，重入锁对逻辑的控...
谈谈显示锁Lock和Synchronized
qq_32445069的博客
08-06 236
Lock接口和synchronized的比较 Lock是一个接口，而synchronized是java的一个关键字。 Lock适用于以下场景：获取锁可以被中断interrupt，超时获取锁，尝试获取锁trylock，读多写少用读写锁。而synchronized就不是可中断锁。 synchronized和ReentrantLock都是可重入锁。 Lock一定要将同步代码块用try catch包起来...
Reentranlock重入锁源码流程图，私聊关注免费给
07-14
重入锁非公平实现方式 线程的状态标识 变量 waitStatus 则表示当前 Node 结点的等待状态，共有5种取值 CANCELLED、SIGNAL、CONDITION、PROPAGATE、0。 CANCELLED(1)：表示当前结点已取消调度。当timeout或被中断...
ReenTrantLock重入锁
weixin_43356265的博客
04-27 196
ReenTrantLock（重入锁） 非公平性锁（默认）：不是按照先后顺序，而是按照抢占式来获得锁， 公平性锁（false）：按照线程请求锁的顺序来获取锁 具体的剖析： ReenTrantLock实现Lock和序列化接口 三个内部类：ync、NonfairSync、FairSync 抽象类Sync继承了 AbstractQueuedSynchronizer（AQS）类 构造函数： Reent...
Java的ReentrantLock(可重入锁)详解上篇
lt_xiaodou的博客
08-24 3264
比如我们有两个线程A，B，第一个线程A已经获取到锁了，B在获取锁的时候肯定获取不到，则会把B包装成Node，然后加入到同步的等待队列中，此时队列中只有一个head头节点和线程B所在的Node节点，head头节点在初始化时，它的waitStatus等于0，在第一次循环时，把头节点的waitStatus更新为SIGNAL，也就是-1，第二次循环时，因为head节点额waitStatus等于-1，所以在第一个if时，直接返回了true，告诉我们可以把当前线程中断掉。
ReentrantLock可重入锁
不羁朔风的博客
11-09 858
ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的。在“公平锁”的机制下，线程依次排队获取锁（先等待的线程先获得锁）；而“非公平锁”在锁是可获取状态时，不管自己是不是在队列的开头都会获取锁。  ReentrantLock和synchronized的相同点 ①ReentrantLock和synchronized一样都具有可重入性 ReentrantLock和s...
重入锁Lock 基本用法
qq_44620773的博客
03-16 579
ReentrantLock是一个类可以实现类似synchronized的功能（jvm实现），但更加灵活。 常用方法 可以看到，lock实现了Lock接口，而接口中有这几个方法 lock()方法:上锁 unlock()方法：释放锁 newCondition()：获得Conditon一个监视器 await() 类似Object wait使当前线程进入等待状态 signal() 类似notifay 唤醒进入等待状态的线程 可以选择模式 公平锁和非公平锁 ReentrantRea.
Lock锁、ReentrantLock(可重入锁)使用
郝开的博客
02-18 549
Lock锁、ReentrantLock可重入锁使用Lock锁ReentrantLock(可重入锁)使用 Lock锁 jdk 5.0开始，Java提供了更强大的线程同步机制，可以显示定义同步锁对象来实现同步。同步锁使用Lock对象充当。 java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前需要先获得Lock对象。 ReentrantLock(可重入锁)类
Lock的tryLock()方法
weixin_30444105的博客
09-10 457
概述 tryLock 是防止自锁的一个重要方式。 tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。 package test; import java.util.concurrent.locks.Lock; import...
trylock的返回值
coldsnow33的专栏
01-10 3097
spinlock：spin_trylock() 成功返回1；否则返回0。 spin_trylock()->raw_spin_trylock()->_raw_spin_trylock()->do_raw_spin_trylock() mutex：mutex_trylock() 成功返回1，失败返回0。 semaphore：down_trylock() 成功返回0，失败返回1。 rw_sema
ReentrantLock中tryLock()和Lock()方法的区别
m0_53611007的博客
10-03 2068
ReentrantLock: Lock():阻塞加锁，无返回值，如果该线程没有获得锁就阻塞，直到获得锁放开 tryLock()：尝试枷锁，布尔类型返回值，线程有锁返回true，反之返回false，不会阻塞 利用tryLock()可以有自旋锁， 自旋锁对cpu消耗较大，但是性能要优于lock()方法 ...
ReentranLock是如何实现可重入性的？
最新发布
03-31
ReentrantLock（可重入锁）的可重入性是通过维护一个计数器和一个持有锁的线程来实现的。当一个线程第一次获取锁时，计数器为1，然后每次该线程再次获取锁时，计数器加1。当该线程释放锁时，计数器减1，直到计数器为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值