Lock的使用（三）——使用ReentrantLock类

最新推荐文章于 2023-02-17 14:28:46 发布
最新推荐文章于 2023-02-17 14:28:46 发布
阅读量119 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44307209/article/details/126464500
版权

目录

1.实现生产者/消费者模式：一对一交替打印

  创建项目4.1.7，类MyService.java,代码如下：

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

public class MyService {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean hasValue = false;
    public void set(){
        try{
            lock.lock();
            while (hasValue == true){
                condition.await();
            }
            System.out.println("打印★");
            hasValue = true;
            condition.signal();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void get(){
        try {
            lock.lock();
            while (hasValue == false){
                condition.await();
            }
            System.out.println("打印☆");
            hasValue = false;
            condition.signal();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

线程类MyThreadA.java代码如下：

public class MyThreadA extends Thread{
    private MyService service;
    public MyThreadA(MyService service){
        this.service = service;
    }

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            service.set();
        }
    }
}

线程类MyThreadB.java代码如下：

public class MyThreadB extends Thread{
    private MyService service;
    public MyThreadB(MyService service){
        this.service = service;
    }

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            service.get();
        }
    }
}

运行类Run.java代码如下：

public class Run {
    public static void main(String[] args) throws InterruptedException{
        MyService service = new MyService();
        MyThreadA a = new MyThreadA(service);
        a.setName("A");
        a.start();
        MyThreadB b = new MyThreadB(service);
        b.setName("B");
        b.start();

    }
}

运行结果如下所示：

打印☆
打印★
打印☆
打印★
打印☆
打印★
打印☆
打印★
打印☆
打印★
打印☆
打印★
打印☆
打印★
打印☆
打印★

  由控制台运行结果可知，通过使用Condition对象，成功实现交替打印的效果。

2.实现生产者/消费者模式：多对多交替打印

  创建项目4.1.8，类MyService.java代码如下：

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

public class MyService {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean hasValue = false;
    public void set(){
        try{
            lock.lock();
            while (hasValue == true){
                System.out.println("有可能★★ 连续");
                condition.await();
            }
            System.out.println("打印★");
            hasValue = true;
            condition.signal();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void get(){
        try {
            lock.lock();
            while (hasValue == false){
                System.out.println("有可能☆☆ 连续");
                condition.await();
            }
            System.out.println("打印☆");
            hasValue = false;
            condition.signal();
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

线程类MyThreadA.java代码如下：

public class MyThreadA extends Thread{
    private MyService service;
    public MyThreadA(MyService service){
        this.service = service;
    }

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            service.set();
        }
    }
}

线程类MyThreadB.java代码如下：

public class MyThreadB extends Thread{
    private MyService service;
    public MyThreadB(MyService service){
        this.service = service;
    }

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            service.get();
        }
    }
}

运行类Run.java代码如下：

public class Run {
    public static void main(String[] args) throws InterruptedException{
        MyService service = new MyService();
        MyThreadA[] threadA = new MyThreadA[10];
        MyThreadB[] threadB = new MyThreadB[10];
        for (int i = 0; i < 10; i++) {
            threadA[i] = new MyThreadA(service);
            threadB[i] = new MyThreadB(service);
            threadA[i].start();
            threadB[i].start();
        }

    }
}

运行结果如下所示：
程序运行出现假死情况

打印★
有可能★★ 连续
打印☆
有可能☆☆ 连续
打印★
有可能★★ 连续
有可能★★ 连续
有可能★★ 连续
打印☆
有可能☆☆ 连续
有可能☆☆ 连续
打印★
有可能★★ 连续
有可能★★ 连续
有可能★★ 连续
打印☆
有可能☆☆ 连续
打印★
有可能★★ 连续
有可能★★ 连续
打印☆
有可能☆☆ 连续
有可能☆☆ 连续

  这种情况可以使用siganlAll()方法来解决。将MyService.java类中的两处signal()代码给成siganlAll()后，程序得到正确运行，就会正确运行。从控制台输出，可以发现这样也解决了假死问题。
  控制台中“打印★”和“打印☆”是交替输出的，但是“有可能★★连续”和“有可能☆☆连续”却不是交替输出的，有时候出现连续打印的情况。原因是程序中使用了一个Condition对象，再结合signalAll()方法来唤醒所有的线程，那么唤醒的线程就有可能是同类，所以就出现连续打印“有可能★★连续”或“有可能☆☆连续”的情况了。

3.公平锁与非公平锁

  公平与非公平锁:锁Lock分为"公平锁"和"非公平锁"，公平锁标识线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序，而非公平锁就是一种获取锁的抢占机制，是随机获得锁的，和公平锁不一样的就是先来的不一定先得到锁，这个方式可能造成某些线程一直拿不到锁，结果也就是不公平的了。
  创建java项目4.1.9，Service.java类，代码如下：

import java.util.concurrent.locks.ReentrantLock;

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()+"获得锁定");
        }finally {
            lock.unlock();
        }
    }
}

创建公平锁运行类Run.java代码如下：

public class Run {
    public static void main(String[] args) throws InterruptedException{
        final Service service = new Service(true);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("★线程"+Thread.currentThread().getName()+"运行了");
                service.serviceMethod();
            }
        };
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threads[i].start();
        }
    }
}

程序运行结果如下所示：

★线程Thread-0运行了
★线程Thread-1运行了
ThreadName = Thread-0获得锁定
★线程Thread-5运行了
ThreadName = Thread-1获得锁定
ThreadName = Thread-5获得锁定
★线程Thread-6运行了
ThreadName = Thread-6获得锁定
★线程Thread-3运行了
ThreadName = Thread-3获得锁定
★线程Thread-4运行了
ThreadName = Thread-4获得锁定
★线程Thread-9运行了
ThreadName = Thread-9获得锁定
★线程Thread-7运行了
ThreadName = Thread-7获得锁定
★线程Thread-2运行了
ThreadName = Thread-2获得锁定
★线程Thread-8运行了
ThreadName = Thread-8获得锁定

打印的结果基本是呈有序状态，这就是公平锁的特点。

  创建非公平锁运行类RunNotFair.java代码如下：

public class RunNotFair {
    public static void main(String[] args) throws InterruptedException {
        final Service service = new Service(false);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("★线程" + Thread.currentThread().getName() + "运行了");
                service.serviceMethod();
            }
        };
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threads[i].start();
        }
    }
}

程序运行结果如下所示:

★线程Thread-0运行了
★线程Thread-4运行了
★线程Thread-3运行了
★线程Thread-2运行了
★线程Thread-1运行了
★线程Thread-6运行了
★线程Thread-5运行了
ThreadName = Thread-0获得锁定
★线程Thread-7运行了
ThreadName = Thread-7获得锁定
★线程Thread-8运行了
ThreadName = Thread-8获得锁定
ThreadName = Thread-4获得锁定
★线程Thread-9运行了
ThreadName = Thread-9获得锁定
ThreadName = Thread-3获得锁定
ThreadName = Thread-2获得锁定
ThreadName = Thread-1获得锁定
ThreadName = Thread-6获得锁定
ThreadName = Thread-5获得锁定

  非公平锁的运行结果基本上是乱序的，说明先start()启动的线程不代表先获得锁。


以上代码下载请点击该链接：https://github.com/Yarrow052/Java-package.git

Yarrow-Y
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Lock的使用（五）——使用ReentrantLock类
qq_44307209的博客
08-25 247
（3）方法void tryLock(long timeout,TimeUnit unit)的作用是：如果给定线程在等待时间内未被另一个线程保持，且当前线程未被中断，则获取该锁定。（1）方法void lockInterruptibly()的作用是：如果当前线程未被中断，则获取锁定(需要等待别的线程释放锁才行)，如果已被中断则出现异常。该实验使用的是Lock()方法，说明线程B被interrupt中断了，那么执行lock()则不出现异常，正常执行。在默认的情况下，ReentrantLock类使用的是非公平锁。
Lock的使用（六）——使用ReentrantLock类
qq_44307209的博客
08-26 197
使用Condition对象可以对线程执行的业务进行排序规划。说明线程在等待时间到达前，可以被其他线程提前唤醒。程序运行后出现异常，这是正常现象。2秒后被其他线程所唤醒。10秒后自动唤醒自己。...
Lock的使用（四）——使用ReentrantLock类
qq_44307209的博客
08-25 126
比如说有5个线程，每个线程都执行了同一个condition对象的await()方法，则调用getWaitQueueLength(Condition condition)方法的返回值是5。比如有5个线程，1个线程首先执行await()方法，那么在调用getQueueLength()方法后返回值是4，说明有4个线程同时在等待lock的释放。（1）方法int getHoldCount()的作用是查询当前线程保持锁定的个数，也就是调用lock()方法的次数。创建项目4.1.10。创建项目4.1.11。
Lock的使用（二）——使用ReentrantLock类
qq_44307209的博客
08-22 215
可以先对线程进行分组，然后再唤醒指定组中的线程。Object类中的 wait(long timeout)方法相当于Condition类中的await(long time,TimeUnit unit)方法。Object类中的notifyAll()方法相当于Condition类中的signalAll()方法。Object类中的notify()方法相当于Condition类中的signal()方法。Object类中的wait()方法相当于Condition类中的await()方法。成功实现等待/通知模式。
java锁类型详解（ReentrantLock/ReentrantReadWriteLock）
雨剑的博客
07-20 711
目录一.公平锁二.非公平锁三.可重入锁 总结一下java各种锁。 一.公平锁 公平锁：是指多个线程按照申请锁的顺序来获取锁；每个线程在获取锁时，先查看此锁维护的等待队列，如果为空或当前线程是队列中的第一个，就获取锁，否则就会加如到等待队列中。类似食堂打饭，先来后到。 二.非公平锁 非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请锁的线程先获取锁；线程上来就尝试占有锁，如果尝试...
Lock、Synchoronized和ReentrantLock的使用
11-11
Lock、Synchronized 和 ReentrantLock 是 Java 中三种常用的同步机制，每种机制都有其特点和使用场景。下面对这三种机制进行详细的分析和比较。 一、Synchronized Synchronized 是 Java 中最基本的同步机制，它...
使用ReentrantLock和Lambda表达式让同步更
11-22
使用ReentrantLock和Lambda表达式让同步更纯净Java开发Java经验技巧共5页.pdf.zip
Java并发之ReentrantLock类源码解析
08-27
主要为大家详细介绍了Java并发系列之ReentrantLock源码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java中ReentrantLock的使用.docx
06-21
可重入锁: 也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，...ReentrantLock 在Java也是一个基础的锁，ReentrantLock 实现Lock接口提供一系列的基础函数,开发人员可以灵活的是应用函数满足各种复杂多变应用场景；
ReentrantLock的使用及注意事项
12-19
ReentrantLock的使用及注意事项
ReentrantLock的四种加锁方式
谈下一个话题，假如.......
10-29 5603
ReentrantLock的四种加锁方式
重入锁ReentrantLock用法以及如何实现重进入
weixin_30394669的博客
02-19 166
　　在java多线程中，可以使用synchronized实现线程之间的同步互斥，但在jdk1.5中增加了ReentrantLock类也能达到同样的效果，而且在使用上更加灵活，扩展功能上更加强大。 　　创建MyService.java类，代码如下： package com.lit.reentreantlock; import java.util.concurrent.locks.Loc...
ReentrantLock介绍及使用(超详细)
热门推荐
Mr.绵羊的知识星球
02-17 1万+
1. Reentrantlock介绍及使用 2. 公平锁和非公平锁 3. Reentrantlock的使用案例 4. Reentrantlock使用时注意事项
ReentrantLock加锁和解锁
Yuwen_forJava的博客
02-15 2202
1.ReentrantLock 1.1 ReentrantLock是什么 ReentrantLock 意思为可重入锁，指的是一个线程能够对一个临界资源重复加锁。 ReentrantLock内部实现依赖于AQS。 1.2 AQS是什么 AQS（AbstractQueuedSynchronizer）是抽象队列同步器，在线程访问共享资源时候，会先判断资源是否上锁了， 如果上锁了，那么把该线程放入CLH队列中进行等待； 如果没上锁，那么把该线程设置为工作线程。 AQS的主要原理图： AQS 使用一
ReentrantLock 锁详解
m0_37235955的博客
04-27 3234
ReentrantLock 支持公平锁和非公平锁，可重入锁 ReentrantLock的底层是通过 **AQS[链接]**实现。 一、BAT 大厂的面试题 **【1】**什么是可重入，什么是可重入锁? 它用来解决什么问题? 【2】ReentrantLock 的核心是 AQS，那么它怎么来实现的，继承吗? 说说其类内部结构关系。 【3】ReentrantLock 是如何实现公平锁的? 【4】ReentrantLock 是如何实现非公平锁的? 【5】ReentrantLock 默认实现的是公平还是非公平锁.
ReentrantLock 在@Transactional事务注解内的Service方法失效
weixin_39360124的博客
09-03 540
业务场景如下: 在单体应用高并发场景, 全校所有学生开始选课, 选课大家都是抢着选择热门的选修课的, 所以会产生高并发, 热门课程的席位是有限的, 比如某个热门课程仅限 100 名学生, 但是高并发场景下,执行以下代码, 经常超过100名学生抢到该热门课程 以下代码只是大概, 并非可完整执行, 只是用于解释问题; //可重入锁,默认是非公平锁 private Lock lock = new ReentrantLock(true); @Autowired private CourseMapper cou
深入浅析Lock—ReentrantLock
m0_46506372的博客
07-30 274
Reentrant
ReentrantLock实现原理
weixin_30687587的博客
02-15 390
以下是本篇文章的大纲 1 synchronized和lock 1.1synchronized的局限性 1.2 Lock简介 2 AQS 3 lock()与unlock()实现原理 3.1 基础知识 3.2 内部结构 3.3 NonfairSync 3.3.1 lock() 3.3.2 unlock() 3.3.3 小结 3.4 FairS...
Thread详解13：ReentrantLock的用法（一）
cds86333774的博客
03-31 4937
Java里面提供了比synchronized更加灵活丰富的锁机制，它们有一个共同的接口Lock，我们先来学习这个接口，了解其协议和功能。下面是JDK文档，总结得非常精炼，包含的知识点非常多，所以一开始可能看不懂，不过没关系，后面一点点弄懂。public interface LockLock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具
ReentrantLock trylock使用
最新发布
04-13
tryLock()是ReentrantLock类中的一个方法，用于尝试获取锁。如果锁可用，则获取锁并立即返回true；如果锁不可用，则立即返回false，而不会阻塞线程。 使用tryLock()方法时需要注意以下几点： 1. 如果tryLock()返回...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值