Java多线程编程-ReentrantLock(1)

最新推荐文章于 2023-06-14 16:42:20 发布
最新推荐文章于 2023-06-14 16:42:20 发布
阅读量124 收藏
点赞数
分类专栏： Java多线程 文章标签： java多线程 ReentrantLock Condition 通知等待 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qian1314520hu/article/details/115377596
版权

Java多线程编程-ReentrantLock使用及其源码解析


在java多线程开发中，我们可以使用 synchronized关键字来实现线程之间的同步互斥，我们也可以使用 ReentrantLock实现更多的功能，如嗅探锁定。多路分支通知等功能，使用上会比synchronized更加灵活。

ReentrantLock简单使用

可重入的互斥Lock，具有与使用sync方法和语句访问的隐式监视器锁相同的基本行为和语义。
由上一次成功锁定但尚未解锁的线程所有。当该锁不属于另一个线程时，调用lock的线程将返回，并成功获取该锁。如果当前线程已经拥有该锁，则该方法将立即返回。可以使用方法 isHeldByCurrentThread和getHoldCount进行检查。

public class ReentrantLockV1Main {
    public static ReentrantLock reentrantLock = new ReentrantLock();
    public static void main(String[] args) {
        Thread thread01 = new Thread(() -> {
            reentrantLock.lock();
            try {
                for (int i = 0; i < 5; i++) {
                    System.out.println("current thread name :" + Thread.currentThread().getName() + " value:" + (i + 1));
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();
            }
        }, "thread01");

        Thread thread02 = new Thread(() -> {
            reentrantLock.lock();
            try {
                for (int i = 0; i < 5; i++) {
                    System.out.println("current thread name :" + Thread.currentThread().getName() + " value:" + (i + 1));
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();
            }
        }, "thread02");

        Thread thread03 = new Thread(() -> {
            reentrantLock.lock();
            try {
                for (int i = 0; i < 5; i++) {
                    System.out.println("current thread name :" + Thread.currentThread().getName() + " value:" + (i + 1));
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();
            }
        }, "thread03");
        thread01.start();
        thread02.start();
        thread03.start();
    }
}

运行结果：
在这里插入图片描述
使用lock方法获取锁，使用unlock方法释放锁。每个线程同步执行。

ReentrantLock实现等待通知

我们知道synchronized和wait/notify可以实现等待通知模式，ReentrantLock也可以实现，但是要借助Condition对象。在一个lock对象里面可以创建多个condition实例，线程对象可以注册在指定的condition中，从而可以有选择性的进行线程的通知。在调度线程上更加灵活。
在没有获得锁的情况下，进行wait操作会报错：

public class ReentranLockObj1 {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void waitFun() {
        try {
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程类：

public class ReentranLockObj1T1 extends Thread {

    private ReentranLockObj1 reentranLockObj1;

    public ReentranLockObj1T1(ReentranLockObj1 reentranLockObj1) {
        this.reentranLockObj1 = reentranLockObj1;
    }

    @Override
    public void run() {
        reentranLockObj1.waitFun();
    }
}

运行结果：
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210404105032778.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpYW4xMzE0NTIwaHU=,size_16,color_FFFFFF,t_70

我们看看该类的Condition接口源码：

public interface Condition {
//使当前线程等待，直到发出信号或被中断
void await() throws InterruptedException;
//使当前线程等待，直到发出信号
void awaitUninterruptibly();
//使当前线程等待，直到发出信号或被中断或经过指定的等待时间为止
long awaitNanos(long nanosTimeout) throws InterruptedException;
//使当前线程等待，直到发出信号或被中断，或者经过指定的等待时间
boolean await(long time, TimeUnit unit) throws InterruptedException;
//使当前线程等待，直到发出信号或被中断，或者经过指定的截止时间
boolean awaitUntil(Date deadline) throws InterruptedException;
//唤醒一个等待的线程
void signal();
//唤醒所有的等待线程
void signalAll();
}

我们只需要将ReentranLockObj1 waitFun方法中添加lock即可，修改如下：

public void waitFun() {
        lock.lock();
        try {
            System.out.println("current thread name :" + Thread.currentThread().getName());
            condition.await();
            System.out.println("current thread name :" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

看看运行结果：
在这里插入图片描述
await方法后面的语句没有输入到控制台，处于等待状态。
进行通知唤醒：

public class ReentranLockObj2 {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    /**
     * 等待
     */
    public void waitFun() {
        lock.lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName());
            condition.await();
            System.out.println("current thread name:" + Thread.currentThread().getName());
        } catch (IllegalMonitorStateException | InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 唤醒
     */
    public void notifyFun() {
        lock.lock();
        try {
            condition.signal();
        } catch (IllegalMonitorStateException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class ReentranLockObj1T2Main {

    public static void main(String[] args) throws InterruptedException {
        ReentranLockObj2 reentranLockObj2 = new ReentranLockObj2();
        ReentranLockObj2T2 reentranLockObj2T2 = new ReentranLockObj2T2(reentranLockObj2);
        reentranLockObj2T2.start();
        Thread.sleep(1000);
        reentranLockObj2.notifyFun();
    }
}

运行结果：
在这里插入图片描述
打印第一句，1秒之后打印第二句，使用signal()唤醒。唤醒所有等待中的线程，使用signalAll()

public class ReentranLockObj3 {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void waitFun1() {
        lock.lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName());
            condition.await();
            System.out.println("current thread name:" + Thread.currentThread().getName());
        } catch (IllegalMonitorStateException | InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void waitFun2() {
        lock.lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName());
            condition.await();
            System.out.println("current thread name:" + Thread.currentThread().getName());
        } catch (IllegalMonitorStateException | InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void notifyAllFun() {
        lock.lock();
        try {
            condition.signalAll();
        } catch (IllegalMonitorStateException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

线程1：

public class ReentranLockObj3T1 extends Thread {

    private ReentranLockObj3 reentranLockObj3;

    public ReentranLockObj3T1(ReentranLockObj3 reentranLockObj3, String threadName) {
        this.reentranLockObj3 = reentranLockObj3;
        this.setName(threadName);
    }

    @Override
    public void run() {
        reentranLockObj3.waitFun1();
    }
}

线程2：

public class ReentranLockObj3T2 extends Thread {

    private ReentranLockObj3 reentranLockObj3;

    public ReentranLockObj3T2(ReentranLockObj3 reentranLockObj3, String threadName) {
        this.reentranLockObj3 = reentranLockObj3;
        this.setName(threadName);
    }

    @Override
    public void run() {
        reentranLockObj3.waitFun2();
    }
}

运行结果：
在这里插入图片描述
先输出上面两行，等5分钟通过调用signalAll进行唤醒所有等待中的线程。
如果想单独唤醒一个，该怎么处理呢？ 我们需要创建多个condition进行处理了。通过condition唤醒部分线程，可以有效提高程序运行效率。

public class ReentranLockObj4 {

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();

    public void waitFunCondition1() {
        lock.lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName());
            condition1.await();
            System.out.println("current thread name:" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void waitFunCondition2() {
        lock.lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName());
            condition2.await();
            System.out.println("current thread name:" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void notifyFunCondition1() {
        lock.lock();
        try {
            condition1.signalAll();
        } catch (IllegalMonitorStateException e) {
            e.printStackTrace();
        } finally {

            lock.unlock();
        }
    }

    public void notifyFunCondition2() {
        lock.lock();
        try {
            condition2.signalAll();
        } catch (IllegalMonitorStateException e) {
            e.printStackTrace();
        } finally {

            lock.unlock();
        }
    }

}

线程1：

public class ReentranLockObj4T1 extends Thread {

    private ReentranLockObj4 reentranLockObj4;

    public ReentranLockObj4T1(ReentranLockObj4 reentranLockObj4, String threadName) {
        this.reentranLockObj4 = reentranLockObj4;
        this.setName(threadName);
    }

    @Override
    public void run() {
        reentranLockObj4.waitFunCondition1();
    }
}

线程2:

public class ReentranLockObj4T2 extends Thread {

    private ReentranLockObj4 reentranLockObj4;

    public ReentranLockObj4T2(ReentranLockObj4 reentranLockObj4, String threadName) {
        this.reentranLockObj4 = reentranLockObj4;
        this.setName(threadName);
    }

    @Override
    public void run() {
        reentranLockObj4.waitFunCondition2();
    }
}

运行：

public class ReentranLockObj4Main {

    public static void main(String[] args) throws InterruptedException {
        ReentranLockObj4 reentranLockObj4 = new ReentranLockObj4();
        ReentranLockObj4T1 reentranLockObj4T1 = new ReentranLockObj4T1(reentranLockObj4, "thread01");
        reentranLockObj4T1.start();
        ReentranLockObj4T2 reentranLockObj4T2 = new ReentranLockObj4T2(reentranLockObj4, "thread02");
        reentranLockObj4T2.start();
        Thread.sleep(5000);
        reentranLockObj4.notifyFunCondition1();
    }

}

运行结果：
在这里插入图片描述
有运行可以看出，当线程1唤醒的时候，调用线程1的wait后的方法，线程2没有调用，就还在等待中，程序没有结束。由此可以得出结论，ReentrantLock可以唤醒指定种类的线程。
总结一下：
1.Object类中的wait相当于Condition中的await
2.Object类中的wait(long timeout) 相当于Condition中的await(long timeout,TimeUnit unit)
3.Object类中的notify相当于Condition中的signal
4.Object类中的notifyAll相当于Condition中的signalAll

Tony-devj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
ReentrantLock介绍及使用(超详细)
Mr.绵羊的知识星球
02-17 1万+
1. Reentrantlock介绍及使用 2. 公平锁和非公平锁 3. Reentrantlock的使用案例 4. Reentrantlock使用时注意事项
ReentrantLock 锁详解
m0_37235955的博客
04-27 3352
ReentrantLock 支持公平锁和非公平锁，可重入锁 ReentrantLock的底层是通过 **AQS[链接]**实现。 一、BAT 大厂的面试题 **【1】**什么是可重入，什么是可重入锁? 它用来解决什么问题? 【2】ReentrantLock 的核心是 AQS，那么它怎么来实现的，继承吗? 说说其类内部结构关系。 【3】ReentrantLock 是如何实现公平锁的? 【4】ReentrantLock 是如何实现非公平锁的? 【5】ReentrantLock 默认实现的是公平还是非公平锁.
Java 中的Lock锁对象(ReentrantLock/ReentrantReadWriteLock)详解
swadian2008的博客
08-29 3154
当有线程获取读锁时，如果当前没有线程持有写锁，则读锁将立即被获取，读锁计数器加一，表示当前有一个线程持有读锁。在 getValue() 方法中，线程会获取锁，返回共享变量 value 的值，最后释放锁。例如，如果一个线程在尝试获取锁的过程中遇到了饥饿现象（即一直获取不到锁），那么系统可能会采用类似于睡眠的方式，让该线程暂时让出 CPU 资源，等待一段时间后再次尝试获取锁。接着，它获取读锁，释放写锁，这样就实现了锁降级。这是因为写锁是独占锁，不能被多个线程同时持有，而读锁是共享锁，可以被多个线程同时持有。
ReentrantLock简单理解
qq_36138652的博客
06-14 2083
ReentrantLock
ReentrantLock介绍
WYSCODER的博客
05-15 3851
ReentrantLock介绍
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
在Java多线程编程中，ReentrantLock提供了更灵活的锁管理机制，相比synchronized，它允许更细粒度的控制，并且提供了更多的同步原语。以下是一些使用ReentrantLock的关键点： 1. **可重入性**：ReentrantLock允许一...
JAVA多线程编程技术PDF
08-28
这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点。 首先，多线程的核心概念包括线程的创建与启动。在Java中，可以通过实现Runnable接口或继承Thread类来创建线程。创建后...
Java多线程 ReentrantLock互斥锁详解
08-25
ReentrantLock是Java多线程编程中的一种锁机制，它可以实现线程之间的同步访问资源。ReentrantLock的主要特点是可以重入，即一个线程可以多次获得锁，而不需要释放锁。这种机制可以避免死锁的出现。 ReentrantLock...
Java多线程编程实战指南-核心篇
06-10
《Java多线程编程实战指南-核心篇》是一本深入探讨Java并发编程的书籍，旨在帮助读者掌握在Java环境中创建、管理和同步线程的核心技术。Java的多线程能力是其强大之处，使得开发者能够在同一时间执行多个任务，提高...
Java-Java线程编程教程
最新发布
11-14
在进行Java多线程编程时，要遵循良好的编程实践，如避免长时间持有锁、合理设置线程优先级、使用并发集合（如ConcurrentHashMap、CopyOnWriteArrayList等）以减少同步开销，以及及时关闭不再使用的线程池。...
重入锁ReentrantLock详解
贾欣晓的博客
08-07 1237
重入锁ReentrantLock，顾名思义，就是支持重进入的锁，。除此之外，该锁的还支持获取锁时的公平和非公平性选择。在AQS实现中，当一个线程调用Mutex的lock()方法获取锁之后，如果再次调用lock()方法，则该线程将会被自己所阻塞，原因是Mutex在实现tryAcquire(int acquires)方法时没有考虑占有锁的线程再次获取锁的场景，。简单的说，Mutex是一个不支持重进入的锁。......
ReentrantLock 可重入锁的使用及原理
瞎叨叨的一天的博客
07-07 1146
ReentrantLock 是一个可重入的并且可非阻塞获取的锁
图解ReentrantLock公平锁和非公平锁实现
m0_73311735的博客
10-13 3882
ReentrantLock是Java并发中十分常用的一个类，具备类似synchronized锁的作用。但是相比synchronized, 它具备更强的能力，同时支持公平锁和非公平锁。指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。多个线程加锁时直接尝试获取锁，能抢到锁到直接占有锁，抢不到才会到等待队列的队尾等待。那ReentrantLock中具体是怎么实现公平和非公锁的呢？它们之间又有什么优缺点呢？本文就带大家一探究竟。
Java并发编程之ReentrantLock
qq_42964601的博客
01-31 150
ReentrantLock 相对于 synchronized 它具备如下特点 可中断 可以设置超时时间 可以设置为公平锁 支持多个条件变量 与 synchronized 一样，都支持可重入 基本语法 可重入 可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁 如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住 输出 可打断 示例 输出 注意如果是不可中断模式，那么即使使用了 interrupt 也不会让等待中断 输出 锁超时 立刻失败
Java多线程--ReentrantLock的用法和原理
IT利刃出鞘的博客
11-08 3927
本文介绍Java的JUC中的ReentrantLock（可重入独占式锁）。包括：用法、原理。
多线程之ReentrantLock
qq_41610960的博客
03-15 379
ReentrantLock源码之lock与unlock
Java多线程.ReentrantLock
记录 分享 成就
04-20 428
功能类比 实现了雷同synchronized(obj)的类似同步功能，但跟synchronized(obj)不一样，也就是说reentracntlockojb.lock跟synchronized(reentracntlockojb)不互斥。 ReentrantLock lock中的lock锁的对象是自己，相当于：synchronized(lock){ }。 锁多少次就unlock多少次，否则锁不能释放，或者报IllegalMonitorStateException异常。 lock/unlo...
Java多线程（九）之ReentrantLock与Condition
爱.NET
12-12 552
一、ReentrantLock 类 1.1 什么是reentrantlock java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象，它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现。这就为 Lock 的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或者锁定语义。 ReentrantLock 类实现了 Lock ，它拥有与 ...
java多线程学习 ReentrantLock类的使用
man_zuo的博客
05-25 598
ReentrantLock类 为了保证任何时刻只有一个线程能进入临界区，通常需要给临界区上锁，只有获得锁的线程才能进入临界区。为了达到上锁的目的，我们通常使用synchronized关键字。 在Java SE 5.0之后，java引入了一个ReentrantLock类，也可以实现给代码块上锁和释放锁的效果。 lock方法 和unlock方法 lock() 申请获得锁 如果获得锁,该线程可以继续往下执行 如果该锁已被其他线程获取,当前线程停止运行并进入阻塞状态,等待其他线程释放锁 unlock() 释
Java多线程编程详解
"Java多线程编程学习资料" 在Java编程中，多线程是一个重要的概念，它使得程序能够同时执行多个任务，提高了程序的效率和响应性。本章主要涵盖了五个关键部分： 1. **线程的概念与原理**： - 程序是一组静态指令...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值