探索JAVA并发 - 可重入锁和不可重入锁

最新推荐文章于 2023-01-22 14:39:26 发布
最新推荐文章于 2023-01-22 14:39:26 发布
阅读量150 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014769764/article/details/100517501
版权

什么是可重入锁，什么是不可重入锁，它们是如何实现的？

定义

  • 可重入锁：当线程获取某个锁后，还可以继续获取它，可以递归调用，而不会发生死锁；

  • 不可重入锁：与可重入相反，获取锁后不能重复获取，否则会死锁（自己锁自己）。

不可重入锁

用代码说话。

基于 wait/notify 实现不可重入锁

import java.util.concurrent.locks.ReentrantLock;	
/**	
 * 不可重入锁	
 */	
public class ReentrantForbiddenLock {	
    private Thread owner;// 持有锁的线程，为空表示无人占有	
    /**	
     * 获取锁，锁被占用时阻塞直到锁被释放	
     *	
     * @throws InterruptedException 等待锁时线程被中断	
     */	
    public synchronized void lock() throws InterruptedException {	
        Thread thread = Thread.currentThread();	
        // wait()方法一般和while一起使用，防止因其它原因唤醒而实际没达到期望的条件	
        while (owner != null) {	
            System.out.println(String.format("%s 等待 %s 释放锁", 	
                thread.getName(), owner.getName()));	
            wait(); // 阻塞，直到被唤起	
        }	
        System.out.println(thread.getName() + " 获得了锁");	
        owner = thread;//成功上位	
    }	
    public synchronized void unlock() {	
        //只有持有锁的线程才有资格释放锁，别的线程不能强迫它	
        if (Thread.currentThread() != owner) {	
            throw new IllegalMonitorStateException();	
        }	
        System.out.println(owner.getName() + " 释放了持有的锁");	
        owner = null;	
        notify();//唤醒一个等待锁的线程，也可以用notifyAll()	
    }	
    public static void main(String[] args) throws InterruptedException {	
        ReentrantForbiddenLock lock = new ReentrantForbiddenLock();	
        lock.lock(); // 获取锁	
        lock.lock(); // 还想再来一次	
    }	
}	
/* 输出:	
main 获得了锁	
main 等待 main 释放锁	
*/

第二次调用lock后线程就阻塞了，线程开始等待持有锁的线程放手，然而是它是它就是它。

基于自旋锁实现不可重入锁

自旋锁，即获取锁的线程在锁被占用时，不是阻塞，而是不断循环去尝试，直到获取锁。

  • 好处：线程保持活跃，减少了线程切换的开销

  • 缺点：很消耗CPU，特别是等待时间很长时

import java.util.concurrent.atomic.AtomicReference;	
import java.util.concurrent.locks.ReentrantLock;	
/**	
 * 不可重入锁	
 */	
public class ReentrantForbiddenLock {	
    // 原子引用：持有锁的线程，为空表示无人占有	
    private AtomicReference<Thread> owner = new AtomicReference<>();	
    /**	
     * 获取锁，锁被占用时阻塞直到锁被释放	
     * 使用CAS原子操作，不用synchronized同步了	
     */	
    public void lock() {	
        Thread thread = Thread.currentThread();	
        // compareAndSet: 原子操作，依赖操作系统底层实现	
        // 如果当前持有值为null，则替换为thread，并返回true，否则返回false	
        while (!owner.compareAndSet(null, thread)) {	
            // 真正用时可不敢这样打印，那输出太多了	
            System.out.println(String.format("%s 等待 %s 释放锁",	
                thread.getName(), owner.get().getName()));	
        }	
        System.out.println(thread.getName() + " 获得了锁");	
    }	
    public void unlock() {	
        Thread thread = Thread.currentThread();	
        if (owner.compareAndSet(thread, null)) {	
            System.out.println(thread.getName() + " 释放了锁");	
            return;	
        }	
        //只有持有锁的线程才有资格释放锁，别的线程不能强迫它	
        throw new IllegalMonitorStateException();	
    }	
    public static void main(String[] args) throws InterruptedException {	
        ReentrantForbiddenLock lock = new ReentrantForbiddenLock();	
        lock.lock();	
        lock.lock();	
    }	
}	
/* 输出:	
main 获得了锁	
main 等待 main 释放锁	
main 等待 main 释放锁	
main 等待 main 释放锁	
...	
*/

如果不想磁盘爆掉，不要在自旋过程中随便打印日志?

可重入锁

不可重入锁扩展一下，增加一个计数器，同一个线程每次获取锁计数器加1，释放锁减1，为0时释放锁。

基于自旋锁实现可重入锁

直接用上个例子的代码改一下：

import java.util.concurrent.atomic.AtomicReference;	
import java.util.concurrent.locks.ReentrantLock;	
/**	
 * 不可重入锁	
 */	
public class ReentrantForbiddenLock {	
    // 原子引用：持有锁的线程，为空表示无人占有	
    private AtomicReference<Thread> owner = new AtomicReference<>();	
    // 计数器	
    private int count;	
    /**	
     * 获取锁，锁被占用时阻塞直到锁被释放	
     */	
    public void lock() {	
        Thread thread = Thread.currentThread();	
        if (thread == owner.get()) {	
            count++;	
            System.out.println(thread.getName() + " 再次获得了锁， count = " + count);	
            return;	
        }	
        // compareAndSet: 原子操作，依赖操作系统底层实现	
        // 如果当前持有值为null，则替换为thread，并返回true，否则返回false	
        while (!owner.compareAndSet(null, thread)) {	
            // 真正用时可不敢这样打印，那输出太多了	
            System.out.println(String.format("%s 等待 %s 释放锁",	
                    thread.getName(), owner.get().getName()));	
        }	
        count = 1;//为了便于理解初始化为1	
        System.out.println(thread.getName() + " 获得了锁");	
    }	
    public void unlock() {	
        Thread thread = Thread.currentThread();	
        if (thread == owner.get()) {	
            count--;	
            System.out.println(thread.getName() + " 释放了锁，count = " + count);	
            if (count == 0) {	
                owner.set(null);	
                System.out.println(thread.getName() + " 彻底释放了锁");	
            }	
            return;	
        }	
        //只有持有锁的线程才有资格释放锁，别的线程不能强迫它	
        throw new IllegalMonitorStateException();	
    }	
    public static void main(String[] args) throws InterruptedException {	
        ReentrantForbiddenLock lock = new ReentrantForbiddenLock();	
        lock.lock();	
        lock.lock();	
        lock.unlock();	
        lock.unlock();	
    }	
}	
/* 输出:	
main 获得了锁	
main 再次获得了锁， count = 2	
main 释放了锁，count = 1	
main 释放了锁，count = 0	
main 彻底释放了锁	
*/

可重入锁 synchronized

没错，用于声明同步方法/代码块的synchronized关键字提供的也是一个可重入锁。

同步方法递归测试：

public class Main {	
    public static void main(String[] args) throws Exception {	
        new Thread(() -> {	
            lock(5);	
        }).start();	
        Thread.sleep(1000);	
        System.out.println("我是主线程，我也要来");	
        lock(2);	
    }	
    private static synchronized void lock(int count) {	
        if (count == 0) {	
            return;	
        }	
        try {	
            Thread.sleep(1000);	
        } catch (InterruptedException e) {	
            e.printStackTrace();	
        }	
        System.out.println(Thread.currentThread().getName() + " " + count);	
        lock(count - 1);	
    }	
}	
/* 输出:	
Thread-0 5	
我是主线程，我也要来	
Thread-0 4	
Thread-0 3	
Thread-0 2	
Thread-0 1	
main 2	
main 1	
*/

可重入锁 ReentrantLock

ReentrantLock是Java中很常见的工具类， 从名字就可以看出，它是个可重入锁，用法也很简单：

import java.util.concurrent.locks.ReentrantLock;	
public class Main {	
    public static void main(String[] args) throws Exception {	
        // 构造函数可传入一个布尔，表示是否使用公平锁(公平锁是什么？请听下回分解)	
        ReentrantLock lock = new ReentrantLock(false);	
        new Thread(() -> {	
            lock.lock();	
            System.out.println("A 获取了锁");	
            try {	
                Thread.sleep(10000);	
            } catch (InterruptedException e) {	
                e.printStackTrace();	
            }	
            System.out.println("A 释放了锁");	
            lock.unlock();	
        }).start();	
        new Thread(() -> {	
            System.out.println("B 等待锁");	
            lock.lock();	
            System.out.println("B 获取了锁");	
            lock.unlock();	
            System.out.println("B 释放了锁");	
        }).start();	
    }	
}	
/* 输出:	
A 获取了锁	
B 等待锁	
A 释放了锁	
B 获取了锁	
B 释放了锁	
*/


相关阅读

探索JAVA并发 - 如何处理线程中断

探索JAVA并发 - 如何优雅地取消线程任务

探索JAVA并发 - 同步工具类

探索JAVA并发 - ThreadLocal


 

长按关注，共同进步

640?wx_fmt=jpeg

如有收获，点个在看，诚挚感谢?

acupt
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java开发-awesome-java-master.zip
02-13
8. **持续集成与部署**：Jenkins、Maven、Gradle等工具是开发流程中必不可少的部分，它们能帮助开发者自动化构建、测试和部署。 9. **容器化与云原生**：Docker、Kubernetes等技术引领了现代软件部署的新潮流，学习...
JAVA---POO
03-27
5. **final 关键字**：final 用于修饰类、变量和方法，表示不可改变或不可继承。final 类不能被继承，final 变量一旦赋值后不可更改，final 方法不能被重写。 6. **this 和 super 关键字**：`this` 指代当前对象，`...
Java可重入锁与不可重入锁
robinson_911的专栏
07-15 343
所谓重入锁，指的是以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象上的锁，而其他的线程是不可以的。 synchronized 和 ReentrantLock 都是可重入锁。 可重入锁的意义在于防止死锁。 实现原理是通过为每个锁关联一个请求计数器和一个占有它的线程。当计数为0时，认为锁是未被占有的；线程请求一个未被占有的锁时，JVM将记录锁的占有者，并且将请求计数器置为1 。 如果同一个线程再次请求这个锁，计数将递增； 每次占用线程退出同步块，计数器值将递减。直到计数器为0,锁..
Java可重入锁和不可重入锁概念和区别学习笔记
qq_39199837的博客
09-02 522
可重入锁就是一个类的A、B两个方法，A、B都有获得统一把锁，当A方法调用时，获得锁，在A方法的锁还没有被释放时，调用B方法时，B方法也获得该锁。 这种情景，可以是不同的线程分别调用这个两个方法。也可是同一个线程，A方法中调用B方法，这个线程调用A方法。 synchronized和java.util.concurrent.locks.ReentrantLock是可重入锁 不可重入锁就是一个类的A、B...
实现一个可重入锁和不可重入锁
weixin_33827731的博客
03-28 140
可重入锁，持有锁的线程可以进入任何锁所同步的代码块 不可重入锁： public class Lock { private boolean isLock = false; /** * 同步方法 */ public synchronized void lock() throws InterruptedException { ...
Java并发编程（二）（锁）
最新发布
qq_41449402的博客
01-22 1434
Java并发编程（二）（锁）
不可重入锁和可重入锁分析
zheng2780071070的博客
03-01 255
1.基本概念 锁其实就是把所需要的代码块，资源，或数据锁上，在操作他们的时候只允许一个线程去做操作。最终结果是为了保证cpu计算结果的正确性。 死锁：两个线程由于争抢临界资源或彼此通信而造成的一种阻塞现象。 可重入锁：也叫做递归锁，指的是同一线程外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。 最简单两种可重入锁：Synchronized和ReenTrantLock。Synchronized是依赖于JVM实现的，而ReenTrantLock是JDK实现的 ...
计算机后端-Java-Java高并发从入门到面试教程-容思路.zip
05-21
Java并发模型中的并发容器也是不可忽视的部分，如ConcurrentHashMap、CopyOnWriteArrayList和BlockingQueue等。它们提供了线程安全的数据结构，可以高效地支持并发操作。例如，ConcurrentHashMap在并发环境下提供了...
Java并发编程从入门到精通源码.rar
07-09
Java并发编程是Java开发中的重要领域，特别是在大型分布式系统、多线程应用和服务器端程序设计中不可或缺。这个资源包“Java并发编程从入门到精通源码.rar”显然是为了帮助开发者深入理解并掌握这一关键技能。它包含...
使用synchronized实现Lock接口的lock和unlock方法
远方的少年
06-09 366
public class TestLock implements Lock { private Object lock = new Object(); private long owner = -1; @Override public void lock() { while(owner != -1){ System.out.println(Thread.currentThread().getId() + "等待锁"); ...
java中的锁（悲观锁、乐观锁、可重入锁、不可重入锁、公平锁、非公平锁、自旋锁、阻塞锁...）
weixin_46665411的博客
10-08 2897
① 锁是一种工具，用于控制对共享资源的访问② Lock和synchronized,这两个是最常见的锁，它们都可以达到线程安全的目的，但是在使用和功能上又有较大的不同③ Lock并不是用来替代synchronized,而是当使用synchronized不合适或不满足要求的时候，来提供高级功能的④ Lock接口最常见的实现类是ReentrantLock。
不可重入锁、可重入锁的实现以及测试
沉浸如海
04-08 729
可重入锁定义：线程去请求自己拥有的锁可请求到interface SelfDefineLock{ void lock(); void unlock(); } class Father{ SelfDefineLock lock; Father(SelfDefineLock lock){ this.lock = lock; } void do_(){ lock.lock(); ...
Java中的可重入锁和不可重入锁
Apple_Boy的博客
12-02 2057
锁的简单应用 用lock来保证原子性（this.count++这段代码称为临界区） 什么是原子性，就是不可分，从头执行到尾，不能被其他线程同时执行。 可通过CAS来实现原子操作 CAS(Compare and Swap): CAS操作需要输入两个数值，一个旧值（期望操作前的值）和一个新值，在操作期间先比较下旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。 CAS主要通过c...
java不可重入 锁_Java的可重入锁和不可重入锁
weixin_42681774的博客
02-16 568
前言最近在用Apache的Zookeeper客户端库Curator，Curator实现了一套的分布式锁，有可重入和不可重入，想起其实在单机环境下，Java提供的synchronized 和 ReentrantLock的锁工具，这两个都是可重入锁，所以可重入锁和不可重入锁有什么区别呢，带着这个问题，去网上找答案。主题很多的博客上都是列了怎么实现这两种锁，例如像下面的两段代码：public class...
自旋锁
qq_40577921的博客
09-18 320
package com.itjava.interview; import java.security.PublicKey; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; //自旋锁 public class SpinLockDemo { //原子引用...
Java不可重入锁和可重入锁理解
热门推荐
u012545728的博客
06-28 6万+
最近正在阅读Java ReentrantLock源码，始终对可重入和不可重入概念理解不透彻，进行学习后记录在这里。 基础知识 Java多线程的wait()方法和notify()方法 这两个方法是成对出现和使用的，要执行这两个方法，有一个前提就是，当前线程必须获其对象的monitor（俗称“锁”），否则会抛出IllegalMonitorStateException异常，所以这两个方法必须在同步...
多线程-可重入锁与不可重入锁
天道酬勤
04-02 5991
什么是可重入锁与不可重入锁？ “可重入锁”这四个字分开来解释： 可：可以。 重：再次。 入：进入。 锁：同步锁。 综上所述，“可重入锁”就是这把同步锁可以再次进入。 进入什么？ 进入同步域（即同步代码块/方法或显式锁锁定的代码）。 通俗来讲，可重入锁就是一证通。 只需一个证就可以通过所有相同关卡： 不可重入锁就是：即使每个关卡相同，你也得再拿一个一摸一样的证...
可重入锁和不可重入锁 ReentrantLock & synchronize
z69183787的专栏
02-21 1万+
http://blog.csdn.net/qq838642798/article/details/65441415 https://www.cnblogs.com/dj3839/p/6580765.html 用lock来保证原子性（this.count++这段代码称为临界区） 什么是原子性，就是不可分，从头执行到尾，不能被其他线程同时执行。 可通过CAS来实现原子操作 CAS...
Java不可重入锁和可重入锁原理
旅人的博客
11-04 335
最近正在阅读Java ReentrantLock源码，始终对可重入和不可重入概念理解不透彻，进行学习后记录在这里。 基础知识 Java多线程的wait()方法和notify()方法 这两个方法是成对出现和使用的，要执行这两个方法，有一个前提就是，当前线程必须获其对象的monitor（俗称“锁”），否则会抛出IllegalMonitorStateException异常，所以这两个方法必须在同步块代码里面调用。 wait()：阻塞当前线程 notify()：唤起被wait()阻塞的线程 不可重入锁 所谓不可重入
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值