Java并发编程：可重入锁

最新推荐文章于 2022-04-25 13:42:08 发布
最新推荐文章于 2022-04-25 13:42:08 发布
阅读量118 收藏
点赞数
分类专栏： java开发 文章标签： java高并发

版权声明：本文为张仕宗原创文章，允许转载，转载时请务必标明文章原始出处 。 https://blog.csdn.net/zhang5476499/article/details/83794711

关于线程安全的例子，我前面的文章Java并发编程：线程安全和ThreadLocal里面提到了,简而言之就是多个线程在同时访问或修改公共资源的时候，由于不同线程抢占公共资源而导致的结果不确定性，就是在并发编程中经常要考虑的线程安全问题。前面的做法是使用同步语句synchronized来隐式加锁，现在我们尝试来用Lock显式加锁来解决线程安全的问题，先来看一下Lock接口的定义:

public interface Lock

Lock接口有几个重要的方法：

//获取锁，如果锁不可用，出于线程调度目的，将禁用当前线程，并且在获得锁之前，该线程将一直处于休眠状态。
void lock()
//释放锁，
void unlock()

lock()和unlock()是Lock接口的两个重要方法，下面的案例将会使用到它俩。Lock是一个接口，实现它的子类包括：可重入锁：ReentrantLock, 读写锁中的只读锁：ReentrantReadWriteLock.ReadLock和读写锁中的只写锁：ReentrantReadWriteLock.WriteLock 。我们先来用一用ReentrantLock可重入锁来解决线程安全问题，如何还不明白什么是线程安全的同学可以回头看我文章开头给的链接文章。

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

public class MyThread implements Runnable {
private int number = 5; //公共变量，5个线程都会访问和修改该变量

private Lock lock = new ReentrantLock(); //可重入锁

@Override
public void run() {
    lock.lock(); //进方法的第一件事就是锁住该方法，不能让其他线程进来
    try {
        number--;
        System.out.println("线程 : " + Thread.currentThread().getName() + "获取到了公共资源，number = " + number);
        Thread.sleep((long)(Math.random()*1000));
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock(); //释放锁
    }
}

public static void main(String[] args) {
    //起5个线程
    MyThread mt = new MyThread();
    Thread t1 = new Thread(mt, "t1");
    Thread t2 = new Thread(mt, "t2");
    Thread t3 = new Thread(mt, "t3");
    Thread t4 = new Thread(mt, "t4");
    Thread t5 = new Thread(mt, "t5");
    t1.start();
    t2.start();
    t3.start();
    t4.start();
    t5.start();
   }
 }

控制台输出：

线程 : t1获取到了公共资源，number = 4
线程 : t2获取到了公共资源，number = 3
线程 : t3获取到了公共资源，number = 2
线程 : t4获取到了公共资源，number = 1
线程 : t5获取到了公共资源，number = 0

程序中创建了一把锁，一个公共变量的资源，和5个线程，每起一个线程就会对公共资源number做自减操作，从上面的输出可以看到程序中的5个线程对number的操作得到正确的结果。需要注意的是，在你加锁的代码块的finaly语句一定要释放锁，就是调用一下lock的unlock()方法。

现在来看一下什么是可重入锁 ，可重入锁就是同一个线程多次尝试进入同步代码块的时候，能够顺利的进去并执行。实例代码如下：

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

public class MyThread implements Runnable {
private int number = 5; //公共变量，5个线程都会访问和修改该变量

private Lock lock = new ReentrantLock(); //可重入锁

public void sayHello(String threadName) {
    lock.lock();
    System.out.println("Hello!线程: " + threadName);
    lock.unlock();
}

@Override
public void run() {
    lock.lock(); //进方法的第一件事就是锁住该方法，不能让其他线程进来
    try {
        number--;
        System.out.println("线程 : " + Thread.currentThread().getName() + "获取到了公共资源，number = " + number);
        Thread.sleep((long)(Math.random()*1000));
        sayHello(Thread.currentThread().getName());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock(); //释放锁
    }
}

public static void main(String[] args) {
    //起5个线程
    MyThread mt = new MyThread();
    Thread t1 = new Thread(mt, "t1");
    Thread t2 = new Thread(mt, "t2");
    Thread t3 = new Thread(mt, "t3");
    Thread t4 = new Thread(mt, "t4");
    Thread t5 = new Thread(mt, "t5");
    t1.start();
    t2.start();
    t3.start();
    t4.start();
    t5.start();
}
}

上述代码什么意思呢？意思是每起一个线程的时候，线程运行run方法的时候，需要去调用sayHello()方法，那个sayHello()也是一个需要同步的和保证安全的方法，方法的第一行代码一来就给方法上锁，然后做完自己的工作之后再释放锁，工作期间，禁止其他线程进来，除了本线程除外。上面代码输出：

线程 : t1获取到了公共资源，number = 4
Hello!线程: t1
线程 : t2获取到了公共资源，number = 3
Hello!线程: t2
线程 : t3获取到了公共资源，number = 2
Hello!线程: t3
线程 : t4获取到了公共资源，number = 1
Hello!线程: t4
线程 : t5获取到了公共资源，number = 0
Hello!线程: t5

定义自己的锁需要实现Lock接口，而上面是Lock接口需要实现的方法，我们抛开其他因素，只看lock()和unlock()方法。

public class MyLock implements Lock {

private boolean isLocked = false; //定义一个变量，标记锁是否被使用

@Override
public synchronized void lock() {
    while(isLocked) { //不断的重复判断，isLocked是否被使用,如果已经被占用，则让新进来想尝试获取锁的线程等待，直到被正在运行的线程唤醒
        try {
            wait();
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //进入该代码块有两种情况:
    // 1.第一个线程进来，此时isLocked变量的值为false,线程没有进入while循环体里面
    // 2.线程进入那个循环体里面，调用了wait()方法并经历了等待阶段，现在已经被另一个线程唤醒，
    // 唤醒它的线程将那个变量isLocked设置为true,该线程才跳出了while循环体

    //跳出while循环体，本线程做的第一件事就是赶紧占用线程，并告诉其他线程说：嘿，哥们，我占用了，你必须等待
    isLocked = true; //将isLocked变量设置为true，表示本线程已经占用
}

@Override
public void lockInterruptibly() throws InterruptedException {

}

@Override
public boolean tryLock() {
    return false;
}

@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    return false;
}

@Override
public synchronized void unlock() {
    //线程释放锁，释放锁的过程分为两步
    //1. 将标志变量设置为true,告诉其他线程，你可以占用了，不必死循环了
    //2. 唤醒正在等待中的线程，让他们去强制资源
    isLocked = false;
    notifyAll(); //通知所有等待的线程，谁抢到我不管
}

@Override
public Condition newCondition() {
    return null;
}
}

从上面代码可以看到，这把锁还是照样用到了同步语句synchronized，只是同步的过程我们自己来实现，用户只需要调用我们的锁上锁和释放锁就行了。其核心思想是用一个公共变量isLocked来标志当前锁是否被占用，如果被占用则当前线程等待，然后每被唤醒一次就尝试去抢那把锁一次(处于等待状态的线程不止当前线程一个)，这是lock方法里面使用那个while循环的原因。当线程释放锁时，首先将isLocked变量置为false,表示锁没有被占用，其实线程可以使用了，并调用notifyAll()方法唤醒正在等待的线程，至于谁抢到我不管，不是本宝宝份内的事。

那么上面我们实现的锁是不是一把可重入的锁呢？我们来调用sayHello()方法看看:

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

public class MyThread implements Runnable {
private int number = 5; //公共变量，5个线程都会访问和修改该变量

private Lock lock = new MyLock(); //创建一把自己的锁

public void sayHello(String threadName) {
    System.out.println(Thread.currentThread().getName() + "线程进来，需要占用锁");
    lock.lock();
    System.out.println("Hello!线程: " + threadName);
    lock.unlock();
}

@Override
public void run() {
    lock.lock(); //进方法的第一件事就是锁住该方法，不能让其他线程进来
    try {
        number--;
        System.out.println("线程 : " + Thread.currentThread().getName() + "获取到了公共资源，number = " + number);
        Thread.sleep((long)(Math.random()*1000));
        sayHello(Thread.currentThread().getName());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock(); //释放锁
    }
}

public static void main(String[] args) {
    //起5个线程
    MyThread mt = new MyThread();
    Thread t1 = new Thread(mt, "t1");
    Thread t2 = new Thread(mt, "t2");
    Thread t3 = new Thread(mt, "t3");
    Thread t4 = new Thread(mt, "t4");
    Thread t5 = new Thread(mt, "t5");
    t1.start();
    t2.start();
    t3.start();
    t4.start();
    t5.start();
}
}

为了特意演示效果，我在sayHello方法加锁之前打印一下当前线程的名称，现在控制台输出如下：

线程 : t1获取到了公共资源，number = 4
t1线程进来，需要占用锁

如上所述，t1线程启动并对公共变量做自减的时候，调用了sayHello方法。同一个线程t1,在线程启动的时候获得过一次锁，再在调用sayHello也想要获取这把锁，这样的需求我们是可以理解的，毕竟sayHello方法也时候也需要达到线程安全效果嘛。可问题是痛一个线程尝试获取锁两次，程序就被卡住了，t1在run方法的时候获得过锁，在sayHello方法想再次获得锁的时候被告诉说：唉，哥们，该锁被使用了，至于谁在使用我不管（虽然正在使用该锁线程就是我自己），你还是等等吧！所以导致结果就是sayHello处于等待状态，而run方法则等待sayHello执行完。控制台则一直处于运行状态。

如果你不理解什么是可重入锁和不可重入锁，对比一下上面使用MyLock的例子和使用J.U.C.包下的ReentrantLock俩例子的区别，ReentrantLock是可重入的，而MyLock是不可重入的。
实现一把可重入锁

现在我们来改装一下这把锁，让他变成可重入锁，也就是说：如果我已经获得了该锁并且还没释放，我想再进来几次都行。核心思路是：用一个线程标记变量记录当前正在执行的线程，如果当前想尝试获得锁的线程等于正在执行的线程，则获取锁成功。此外还需要用一个计数器来记录一下本线程进来过多少次，因为如果同步方法调用unlock()时，我不一定就要释放锁，只有本线程的所有加锁方法都释放锁的时候我才真正的释放锁，计数器就起到这个功能。

改装过后的代码如下：

public class MyLock implements Lock {

private boolean isLocked = false; //定义一个变量，标记锁是否被使用

private Thread runningThread = null; //第一次线程进来的时候，正在运行的线程为null

private int count = 0;  //计数器

@Override
public synchronized void lock() {
    Thread currentThread = Thread.currentThread();
    //不断的重复判断，isLocked是否被使用,如果已经被占用，则让新进来想尝试获取锁的线程等待，直到被正在运行的线程唤醒
    //除了判断当前锁是否被占用之外，还要判断正在占用该锁的是不是本线程自己
    while(isLocked && currentThread != runningThread) { //如果锁已经被占用，而占用者又是自己，则不进入while循环
        try {
            wait();
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //进入该代码块有三种情况:
    // 1.第一个线程进来，此时isLocked变量的值为false,线程没有进入while循环体里面
    // 2.线程进入那个循环体里面，调用了wait()方法并经历了等待阶段，现在已经被另一个线程唤醒，
    // 3.线程不是第一次进来，但是新进来的线程就是正在运行的线程，则直接来到这个代码块
    // 唤醒它的线程将那个变量isLocked设置为true,该线程才跳出了while循环体

    //跳出while循环体，本线程做的第一件事就是赶紧占用线程，并告诉其他线程说：嘿，哥们，我占用了，你必须等待,计数器+1,并设置runningThread的值
    isLocked = true; //将isLocked变量设置为true，表示本线程已经占用
    runningThread = currentThread; //给正在运行的线程变量赋值
    count++; //计数器自增
}

@Override
public void lockInterruptibly() throws InterruptedException {

}

@Override
public boolean tryLock() {
    return false;
}

@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    return false;
}

@Override
public synchronized void unlock() {
    //线程释放锁，释放锁的过程分为三步
    //1. 判断发出释放锁的请求是否是当前线程
    //2. 判断计数器是否归零，也就是说，判断本线程自己进来了多少次，是不是全释放锁了
    //3. 还原标志变量
    if(runningThread == Thread.currentThread()) {
        count--;//计数器自减
        if(count == 0) { //判断是否归零
            isLocked = false; //将锁的状态标志为未占用
            runningThread = null;  //既然已经真正释放了锁，正在运行的线程则为null
            notifyAll(); //通知所有等待的线程，谁抢到我不管
        }
    }
}

@Override
public Condition newCondition() {
    return null;
}
}

如代码注释所述，这里新增了两个变量runningThread和count，用于记录当前正在执行的线程和当前线程获得锁的次数。代码的关键点在于while循环判断测试获得锁的线程的条件，之前是只要锁被占用就让进来的线程等待，现在的做法是，如果锁已经被占用，则判断一下正在占用这把锁的就是我自己，如果是，则获得锁，计数器+1;如果不是，则新进来的线程进入等待。相应的，当线程调用unlock()释放锁的时候，并不是立马就释放该锁，而是判断当前线程还有没有其他方法还在占用锁，如果有，除了让计数器减1之外什么事都别干，让最后一个释放锁的方法来做最后的清除工作，当计数器归零时，才表示真正的释放锁。

我知道你在怀疑这把被改造过后的锁是不是能满足我们的需求，现在就让我们来运行一下程序，控制台输出如下:

线程 : t1获取到了公共资源，number = 4
t1线程进来，需要占用锁
Hello!线程: t1
线程 : t5获取到了公共资源，number = 3
t5线程进来，需要占用锁
Hello!线程: t5
线程 : t2获取到了公共资源，number = 2
t2线程进来，需要占用锁
Hello!线程: t2
线程 : t4获取到了公共资源，number = 1
t4线程进来，需要占用锁
Hello!线程: t4
线程 : t3获取到了公共资源，number = 0
t3线程进来，需要占用锁
Hello!线程: t3

嗯，没错，这就是我们想要的结果。

好了，自己动手写一把可重入锁就先写到这了，后面有时间再写一篇用AQS实现的可重入锁，毕竟ReentrantLock这哥们就是用AQS实现的可重入锁，至于什么是AQS以及如何用AQS实现一把可重入锁，且听我慢慢道来。如果你看懂这篇文章的思路或者如果是你看完了这篇文章有动手写一把可重入锁的冲动，麻烦点个赞哦，毕竟大半夜的写文章挺累的，是吧？

作者：SpringChang
来源：CSDN
原文：https://blog.csdn.net/zhang5476499/article/details/83794711
版权声明：本文为博主原创文章，转载请附上博文链接！

L星火燎原
关注
专栏目录
手写实现一个可重入锁！
anguser
12-31 1455
代码如下：public class MyLock implements Lock{ Thread lockBy = null; int lockCount = 0; //锁标志 private boolean isLocked = false; /* * 加锁 * (non-Javadoc) * @see java.util.c
Java并发编程：自己动手写一把可重入锁
张翠山的博客
11-08 6377
线程不安全例子 public class Sequence { private int value; public void increament(int number) { int newValue = value + number; try { Thread.sleep((long) (Math.random() *...
死磕 java同步系列之自己动手写一个锁Lock
weixin_38367817的博客
07-15 184
本文转载于公众号彤哥读源码 ????欢迎关注我的公众号“彤哥读源码”，查看更多源码系列文章, 与彤哥一起畅游源码的海洋。（手机横屏看源码更方便）问题（1）自己动手写一个锁需要哪些知识？（2）自己动手写一个锁到底有多简单？（3）自己能不能写出来一个完美的锁？简介本篇文章的目标一是自己动手写一个锁，这个锁的功能很简单，能进行正常的加锁、解锁操作。本篇文章的目标二是通过自己动手写一个锁，能更好地理解后面章节将要学习的AQS及各种同步器实现的原理。分析自己动手写一个锁需要准备些什么呢？首先，在上一章学习synch
JAVA并发锁-可重入锁ReentrantLock浅析
雪落南城的博客
11-27 274
互联网环境下，我们使用锁大部分都是分布式锁，例如Redis提供的 但是java并发锁的思想还是非常值得学习的。 单机情况下我们使用ReentrantLock如下 public void businessCode() { ReentrantLock lock = new ReentrantLock(); //用法1 lock.lock(); ...
Java并发编程：用AQS写一把可重入锁
02-24
之所以把这一章节叫做AQS简介而不是叫AQS详解，是因为已经有大神写过详解的文章Java并发之AQS详解，这篇文章对AQS的源码解析很透彻，博主读了之后受益匪浅，鉴于对原作者的尊重，所以如上附上原文的链接。...
Java并发编程之重入锁与读写锁
08-29
Java并发编程之重入锁与读写锁 在 Java 并发编程中，重入锁和读写锁是两个非常重要的概念。重入锁是指支持重进入的锁，也就是说，一个线程可以多次获取同一个锁，而不会被阻塞。读写锁则是维护了一对相关的锁，一...
java并发编程实战源码,java并发编程实战pdf,Java
09-10
3. **并发控制**：Java提供了多种并发控制工具，包括synchronized、wait()、notify()、notifyAll()、ReentrantLock（可重入锁）、Semaphore（信号量）和CountDownLatch（倒计时器）等。这些工具用于协调不同线程的...
Java并发编程——锁与可重入锁
u010791823的博客
05-14 265
转载：http://www.jianshu.com/p/007bd7029faf 简单锁 在讲述简单锁的实现之前，我们先来看一个锁的应用例子： public class Counter{ private Lock lock = new Lock(); private int count = 0; public int inc(){ lock.l
实现一个可重入锁
zz0129的博客
07-03 376
可重入锁为当一个线程获得该锁后若未释放前想要再次获取该锁，则可以直接获取不用等待，我们只需要把锁的次数加一即可，释放一次锁次数就减一，直到次数为零，其它线程就可以继续竞争该锁了。package com.lock; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Condition; import ja...
自己动手写一把可重入锁测试案例
11-14
https://blog.csdn.net/zhang5476499/article/details/83794711 【Java并发编程：自己动手写一把可重入锁】中用到的例子。
Java并发编程之重入锁
itmyhome的专栏
07-20 1223
重入锁，顾名思义，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。重进入是指任意线程在获取到锁之后能够再次获取该锁而不会被锁阻塞，该特性的实现需要解决以下两个问题。 1、线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。 2、锁的最终释放。线程重复n次获取了锁，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计
Java 自己动手写一个线程锁
code by code
04-23 280
public class CasTip { private static Unsafe unsafe = UnsafeObject.getUnsafe(); int lock = 0; static long offset; static { try { offset = unsafe.objectFieldOffset(CasTip.class.getDeclaredFiel...
并发编程---------可重入锁
你的C有点长
12-23 404
什么是可重入锁? 指的是同一个线程可以对共享资源进行重复加锁。 具体的实现的可重入锁 Synchronized -------隐式实现 ReentrantLock 这里我就比较重点的描述ReentrantLock。虽然没有和Synchronized一样具有隐式重进入，但能保证调用lock（）方法，再次调用lock（）方法不会阻塞当前线程。 如何实现重进入呢？ ReentrantLock是通过组合自定义同步器来实现所得获取以及释放。其实是用一个整型变量来记录锁次数。-----------
自定义不可重入锁代码
weixin_44836361的博客
09-08 110
public class TestAQS { public static void main(String[] args) { MyLock myLock=new MyLock(); new Thread(()->{ myLock.lock(); try{ System.out.println("locking..."); }finally { .
自己实现可重入锁
小X的书屋
12-04 436
什么是可重入锁 本章的代码在>reentlock 包下 假设现在有一个线程A 他获取了锁，然后他再一次去尝试获取锁，如果能成功，就说这个锁是可以重入的，在java中 ReentrantLock.class就是一个可重入的锁，关于这个类的源码解析，将在后面的章节讲到，现在我们看一下一个可重入锁的基本使用。 使用ReentrantLock 首先我们写一个简单的例子，这个例子是线程不安全的： ...
可重入锁
赵树祥的博客
09-05 608
定义 可重入锁，也叫做递归锁，指的是在同一线程内，外层函数获得锁之后，内层递归函数仍然可以获取到该锁。换一种说法：同一个线程再次进入同步代码时，可以使用自己已获取到的锁。 作用 防止在同一线程中多次获取锁而导致死锁发生。 如下，我们通过自旋锁来判断是否会发生死锁： public class SpinLock { private AtomicReference<Th...
【JUC并发编程】9 可重入锁原理、自己实现一个可重入锁
健身变秃，coding变强
04-25 739
可重入锁实现原理？ 自己实现一个可重入锁
可重入锁 和 不可重入锁的设计
wwww8260919的博客
04-28 163
不可重入锁 public class UnreetrantLock { private boolean isLock = false; public synchronized void lock() throws InterruptedException{ System.out.println("进入锁lock："+Thread.currentThread().g...
Java并发编程：ReentrantLock与读写锁详解
在Java并发编程实践中，第03章深入探讨了Java 5.0引入的高级并发控制机制——重入锁（ReentrantLock）。与传统的内置锁（intrinsic locking）相比，ReentrantLock提供了更为灵活和强大的特性，包括无条件获取、可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值