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

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

目录

1.方法isFair()、isHeldByCurrentThread()和isLocked()的测试

  创建项目4.1.12
（1）方法boolean isFair()的作用是判断是不是公平锁。
创建名称为test1的package包，创建类Service.java代码如下：

package test1;

import java.util.concurrent.locks.ReentrantLock;
public class Service {
    public ReentrantLock lock;
    public Service(Boolean isFair) {
        super();
        lock = new ReentrantLock(isFair);
    }
    public void serviceMethod() {
        try {
            lock.lock();
            System.out.println("公平锁情况：" + lock.isFair());
        } finally {
            lock.unlock();
        }
    }
}

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

package test1;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final Service service1 = new Service(true);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service1.serviceMethod();
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
        final Service service2 = new Service(false);
        runnable = new Runnable() {
            @Override
            public void run() {
                service2.serviceMethod();
            }
        };
        thread = new Thread(runnable);
        thread.start();
    }
}

程序运行结果如下所示：

公平锁情况：true
公平锁情况：false

在默认的情况下，ReentrantLock类使用的是非公平锁。

（2）方法boolean isHeldByCurrentThread()的作用是查询当前线程是否保持此锁定。
创建名称为test2的package包，创建类Service.java代码如下：

package test2;

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 {
            System.out.println(lock.isHeldByCurrentThread());
            lock.lock();
            System.out.println(lock.isHeldByCurrentThread());
        } finally {
            lock.unlock();
        }
    }
}

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

package test2;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final Service service1 = new Service(true);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service1.serviceMethod();
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

程序运行结果如下所示：

false
true

（3）方法boolean isLocked()的作用是查询此锁定是否由任意线程保持。
创建名称为test3的package包，创建类Service.java代码如下：

package test3;

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 {
            System.out.println(lock.isLocked());
            lock.lock();
            System.out.println(lock.isLocked());
        } finally {
            lock.unlock();
        }
    }
}

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

package test3;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final Service service1 = new Service(true);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service1.serviceMethod();
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

程序运行结果如下所示：

false
true

2.方法lock.lockInterruptibly()、tryLock()和tryLock(long timeout,TimeUint uint)的测试

  创建项目4.1.13
（1）方法void lockInterruptibly()的作用是：如果当前线程未被中断，则获取锁定(需要等待别的线程释放锁才行)，如果已被中断则出现异常。
创建名称为test1的package包，创建类MyService.java代码如下：

package test1;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class MyService {
    public ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void waitMethod() {
        try {
            lock.lock();
            System.out.println("lock begin "+Thread.currentThread().getName());
            for (int i = 0; i < Integer.MAX_VALUE / 10; i++) {
                String newString = new String();
                Math.random();
            }
            System.out.println("lock end "+Thread.currentThread().getName());
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

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

package test1;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final MyService service = new MyService();
        Runnable runnableRef = new Runnable() {
            @Override
            public void run() {
                service.waitMethod();
            }
        };
        Thread threadA = new Thread(runnableRef);
        threadA.setName("A");
        threadA.start();
        Thread.sleep(500);
        Thread threadB = new Thread(runnableRef);
        threadB.setName("B");
        threadB.start();
        threadB.interrupt(); //此处中断threadB线程，使用lock.lock()方法
        System.out.println("main end!");
    }
}

程序运行结果如下所示：

lock begin A
main end!
lock end A
lock begin B
lock end B

  没有出现异常，A、B线程正常结束，按钮变灰。
该实验使用的是Lock()方法，说明线程B被interrupt中断了，那么执行lock()则不出现异常，正常执行。

  如果使用lockInterruptibly方法则会出现问题。
将类MyService.java中原有代码“lock.lock()”；变成"lock.lockInterruptibly();"。
程序运行结果如下所示：

lock begin A
main end!
java.lang.InterruptedException
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1219)
	at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:340)
	at test1.MyService.waitMethod(MyService.java:11)
	at test1.Run$1.run(Run.java:9)
	at java.lang.Thread.run(Thread.java:744)
lock end A

线程B被中断后调用lockInterruptibly方法报异常

（2）方法void tryLock()的作用是：仅在调用时锁定未被另一个线程保持的情况下，才获取该锁定。
创建名称为test2的package包，创建类MyService.java代码如下：

package test2;

import java.util.concurrent.locks.ReentrantLock;

public class MyService {
    public ReentrantLock lock = new ReentrantLock();

    public void waitMethod() {
        if (lock.tryLock()) {
            System.out.println(Thread.currentThread().getName() + "获得锁");
        } else {
            System.out.println(Thread.currentThread().getName() + "没有获得锁");
        }
    }
}

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

package test2;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final MyService service = new MyService();
        Runnable runnableRef = new Runnable() {
            @Override
            public void run() {
                service.waitMethod();
            }
        };
        Thread threadA = new Thread(runnableRef);
        threadA.setName("A");
        threadA.start();
        Thread threadB = new Thread(runnableRef);
        threadB.setName("B");
        threadB.start();
    }
}

程序运行结果如下所示：

A获得锁
B没有获得锁

（3）方法void tryLock(long timeout,TimeUnit unit)的作用是：如果给定线程在等待时间内未被另一个线程保持，且当前线程未被中断，则获取该锁定。
创建名称为test3的package包，创建类MyService.java代码如下：

package test3;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class MyService {
    public ReentrantLock lock = new ReentrantLock();
    public void waitMethod() {
        try {
            if(lock.tryLock(3, TimeUnit.SECONDS)) {
                System.out.println(Thread.currentThread().getName()+"获得锁的时间："+System.currentTimeMillis());
                Thread.sleep(10000);
            } else {
                System.out.println(Thread.currentThread().getName()+"没有获得锁");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }
}

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

package test3;

public class Run {
    public static void main(String[] args) throws Exception {
        final MyService service = new MyService();
        Runnable runnableRef = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"调用waitMethod时间："+System.currentTimeMillis());
                service.waitMethod();
            }
        };
        Thread threadA = new Thread(runnableRef);
        threadA.setName("A");
        threadA.start();
        Thread threadB = new Thread(runnableRef);
        threadB.setName("B");
        threadB.start();
    }
}

程序运行结果如下所示：

A调用waitMethod时间：1661327480581
B调用waitMethod时间：1661327480581
A获得锁的时间：1661327480582
B没有获得锁

线程B超时未获得锁


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

Yarrow-Y
关注
第 5-5 课：线程安全——synchronized 和 ReentrantLock + 面试题
磊哥聊Java
10-28 210
前面我们介绍了很多关于多线程的内容，在多线程中有一个很重要的课题需要我们攻克，那就是线程安全问题。线程安全问题指的是在多线程中，各线程之间因为同时操作所产生的数据污染或其他非预期的程序运行结果。 线程安全 1）非线程安全事例 比如 A 和 B 同时给 C 转账的问题，假设 C 原本余额有 100 元，A 给 C 转账 100 元，正在转的途中，此时 B 也给 C 转了 100 元，这个时候 A 先...
线程安全——synchronized 和 ReentrantLock ，看完后绝不后悔系列
csdn681的博客
05-30 439
前面我们介绍了很多关于多线程的内容，在多线程中有一个很重要的课题需要我们攻克，那就是线程安全问题。线程安全问题指的是在多线程中，各线程之间因为同时操作所产生的数据污染或其他非预期的程序运行结果。 线程安全 1）非线程安全事例 比如 A 和 B 同时给 C 转账的问题，假设 C 原本余额有 100 元，A 给 C 转账 100 元，正在转的途中，此时 B 也给 C 转了 100 元，这个时候 A 先给 C 转账成功，余额变成了 200 元，但 B 事先查询 C 的余额是 100 元，转账成功之后也是 2
带你看看Java的锁(一)-ReentrantLock
01-20
带你看看Javad的锁-ReentrantLock前言ReentrantLock简介Synchronized对比用法源码分析代码结构方法分析SyncNonfairSyncFairSync非公平锁VS公平锁什么是公平非公平ReentrantLockReentrantLock的构造函数lock加锁方法非公平的加锁公平的加锁unlock解锁总结公平锁 VS 非公平锁Synchronized VS ReentrantLock 前言 AQS一共花了5篇文章，对里面实现的核心源码都做了注解 也和大家详细描述了下，后面的几篇文字我将和大家聊聊一下AQS的实际使用，主要会聊几张锁，第一篇我会和大家聊下Reen
Lock的使用（四）——使用ReentrantLock类
qq_44307209的博客
08-25 174
比如说有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-15 423
在Java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中心增加了ReentrantLock类也能达到同样的效果，并且在扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知等功能，而且在使用上也比synchronized更加的灵活。...
ReentrantLock类的使用
NULL的博客
11-03 317
一、使用ReentrantLock类 和 synchronized 关键字来实现线程之间的同步互斥一样，ReentrantLock 类也可以达到这样的效果 class MyService2 { private Lock lock = new ReentrantLock(); public void methodA() { //当前线程获得对象锁 ...
显示锁ReentrantLock和Lock的使用
及时雨的csdn
07-07 463
Jdk1.5以后，Doug Lea大神添加了新的多线程的包,在java.util.concurrent.locks下，有一组实现线程同步的接口Lock和类ReentrantLock.ReentrantLock也是Lock接口的唯一实现类. Lock提供了一种无条件的、可轮询的、定时的以及可中断的锁获取操作,所有的加锁和解锁方法都是显示的. public interface Lock { 　　// 用来获取锁，如果锁已经被其他线程获取，则一直等待，直到获取到锁 void lock(); 　　/
多线程的Lock锁——ReentrantLock
weixin_39400271的博客
01-10 339
        在Java多线程中，可以使用synchronized关键字来实现线程之间的同步互斥，但在JDK1.5中新增了Lock锁，同样可以实现同样的效果，并且扩展功能上也更加强大，比如嗅探锁定、多路分支通知等功能，而且使用上也更灵活。         Lock锁分为两类：ReentrantLock和ReentrantReadWriteLock。 这里介绍ReentrantLock类的基础...
JUC源码学习笔记1——AQS和ReentrantLock
xuhss_com的博客
07-11 207
一丶Lock 锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁可以防止多个线程同时访问共享资源（这种锁称为独占锁，排他锁）但是有些锁可以允许多个线程并发访问共享资源，比如读写锁 3.使用Lock的经典范式 获取锁的过程不要写在try中，避免获取锁失败最后finally释放其他线程持有的锁使用一个int成员变量state表示同步状态，内置的FIFO队列来完成资源的获取和线程的排队工作，支持独占也支持共享的获取同步状态。三个变量被volatile修饰，保证其线程可见性等待状态是一个枚举，具备下列可选的值
Lock的使用（六）——使用ReentrantLock类
qq_44307209的博客
08-26 307
使用Condition对象可以对线程执行的业务进行排序规划。说明线程在等待时间到达前，可以被其他线程提前唤醒。程序运行后出现异常，这是正常现象。2秒后被其他线程所唤醒。10秒后自动唤醒自己。...
Lock的使用（三）——使用ReentrantLock类
qq_44307209的博客
08-22 130
原因是程序中使用了一个Condition对象，再结合signalAll()方法来唤醒所有的线程，那么唤醒的线程就有可能是同类，所以就出现连续打印“有可能★★连续”或“有可能☆☆连续”的情况了。公平与非公平锁:锁Lock分为"公平锁"和"非公平锁"，公平锁标识线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序，而非公平锁就是一种获取锁的抢占机制，是随机获得锁的，和公平锁不一样的就是先来的不一定先得到锁，这个方式可能造成某些线程一直拿不到锁，结果也就是不公平的了。
Lock的使用（二）——使用ReentrantLock类
qq_44307209的博客
08-22 286
可以先对线程进行分组，然后再唤醒指定组中的线程。Object类中的 wait(long timeout)方法相当于Condition类中的await(long time,TimeUnit unit)方法。Object类中的notifyAll()方法相当于Condition类中的signalAll()方法。Object类中的notify()方法相当于Condition类中的signal()方法。Object类中的wait()方法相当于Condition类中的await()方法。成功实现等待/通知模式。
ReentrantLock 的使用
u010325193的博客
05-29 5998
作者：骊骅 链接：https://www.jianshu.com/p/155260c8af6c 來源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 一、初识ReentrantLock import java.util.concurrent.locks.ReentrantLock; /** * Created by haicheng.lhc on 17/05/...
并发编程：ReentrantLock应用
Fisher3652的博客
09-15 525
ReentrantLock1. 特点2. 重入3. 可打断4. 超时5. 多条件 1. 特点 可打断，可重入 可以设置超时时间 可以设置为公平锁 支持多个条件变量 支持读写锁 基本语法 reentrantLock.lock(); try { //业务代码 } finally { reentrantLock.unlock(); } 2. 重入 package org.example; import lombok.extern.slf4j.Slf4j; import java.ut
从源码角度理解ReentrantLock（java.util.concurrent.locks.ReentrantLock）
Impassive_y的博客
04-19 946
文章目录一、ReentrantLock介绍二、ReentrantLock继承关系三、Sync3.1 主要实现的方法四、FairSync(公平锁)4.1 加锁4.2 加锁失败，进入等待4.3 释放锁五、非公平锁5.1 加锁5.2 释放锁六、其他方法 一、ReentrantLock介绍 ReentrantLock重入锁，能够实现对同一个资源的重复加锁，即当前线程重复申请资源的时候，在已经拥有锁的前提下...
高并发编程之ReentrantLock工具类讲解
weixin_42146366的博客
02-23 447
一、ReentrantLock介绍 ①、ReentrantLock实现了Lock接口，加锁和解锁都需要显式写出，注意一定要在适当时候unlock。 ②、可重入锁。可重入锁是指同一个线程可以多次获取同一把锁。也是在实际编程中使用频率很高的一个锁，支持重入性，表示能够对共享资源能够重复加锁，即当前线程获取该锁再次获取不会被阻塞 ③、可中断锁。可中断锁是指线程尝试获取锁的过程中，是否可以响应中断。syn...
Java工具类解析系列 -- ReentrantLock
Justinjiang1314的博客
01-24 394
概念 ReentrantLock是一个可重入互斥锁，与synchronized关键字具有相同的基本行为和语义，但具有扩展功能。此锁由上次成功获取但尚未解锁的线程所拥有，此时其它线程尝试获取锁时，将会被阻塞挂起。 名词解释： 可重入 -- 顾名思义，同一个线程可以调用lock方法若干次，同时也需要unlock相应的次数，完成锁的释放。为什么需要可重入，主要目的是为了在代码设计时，当有多个定义的原子操作在组合使用时，可以不必考虑加锁的位置和顺序等。例如： package com.youdao.labo
【ReentrantLock】可重入的互斥锁，又被称为“独占锁”
最新发布
Mouth_OF_Lie的博客
12-28 635
ReentrantLock是一个可重入的互斥锁，又被称为“独占锁”。ReentrantLock锁在同一个时间点只能被一个线程锁持有；可重入表示，ReentrantLock锁可以被同一个线程多次获取。ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的。在“公平锁”的机制下，线程依次排队获取锁；而“非公平锁”在锁是可获取状态时，不管自己是不是在队列的开头都会获取锁。
深入理解Java Lock类：超越synchronized的同步控制
"Java多线程基础——Lock类" 在Java多线程编程中，Lock类的引入是为了提供更细粒度的线程同步控制，相比synchronized关键字，它提供了更多的灵活性和高级特性。Lock接口位于java.util.concurrent.locks包中，它定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值