(四)Lock,ReentrantLock,ReentrantReadWriteLock类的使用以及相关api---synchronized进阶
这篇博客记录了Lock,ReentrantLock,ReentrantReadWriteLock类的使用以及其一些api:
码字不易~~另外《java多线程编程核心技术》这本书读着很爽
前言说明:之前为了解决多线程时的非线程安全问题,使用的是synchronized。接下来记录的是他的升级版本ReentrantLock,更加灵活,可控性更高,而ReentrantReadWriteLock类是对ReentrantLock类的补充,能够在某些条件之间之下提交效率
下面先来看下都有哪些api,以及和synchronized之间是怎样对应的吧。
以前使用锁完成同步是将同步代码块写在synchronized之内,现在我们使用
Lock lock = new ReentrantLock();
来声明一个锁,他有这两个方法
lock.lock(); 和 lock.unlock(); 这两个是配套的,在其之间的代码就是同步代码块。
和之前一样,lock()方法会让当前线程持有对象监听器,具体规则之类的和synchronized也一样,
比如下面的例子,MyService有一段代码上锁,自定义线程类调用它
MyService.java
package 第四章;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; public class MyService {
private Lock lock = new ReentrantLock();
public void testMethod(){
lock.lock();
for(int i=0;i<5;i++){
System.out.println(i+"线程:"+Thread.currentThread().getName());
}
lock.unlock();
}
}
MyThread.java
package 第四章; public class MyThread extends Thread {
private MyService myService; public MyThread(MyService myService) {
super();
this.myService = myService;
} public void run(){
myService.testMethod();
}
}
test.java
package 第四章; public class test {
public static void main(String[] args){
MyThread[] threads = new MyThread[5];
MyService myService = new MyService();
for(int i=0;i<5;i++){
threads[i] = new MyThread(myService);
threads[i].start();
}
}
}
运行结果:
可以看到线程之间是同步执行的,当然前提是同一个MyService对象。
之前的wait/notify,用Condition对象来替换:
效率提高的地方以及原因:
Condition对象可以对同一个锁声明多个,相当于每当让线程等待时,他都有自己的唤醒condition,换句话说,每一个线程都可以注册一个Condition,这样当我们唤醒线程的时候,就可以唤醒指定的线程,比如之前的生产者消费者模型之中的假死现象,我们使用过notifyAll()来解决的,但是这种方法唤醒了所有的线程,让所有线程都去争抢cpu,但是我们事实上指向唤醒异类线程,并不想唤醒同类,全部唤醒的话,效率是一个问题。那么现在,给每一个线程都注册
一个Condition,这样子唤醒时候,我们就可以唤醒指定的线程,提高了效率,也更加灵活。
下面的是一个简单的await/signal例子,展示了基本的使用:await类似之前的wait,signal类似于notify:signalAll()唤醒全部
更改之前的MyService.java
condition.await()让线程阻塞,condition.signal()随机唤醒一个由当前condition注册的线程
package 第四章;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
public class MyService {
private Lock lock = new ReentrantLock();
public Condition condition = lock.newCondition();
public void testMethod(){
try{
lock.lock();
System.out.println("即将开始循环");
condition.await();
for(int i=0;i<2;i++){
System.out.println(i+"线程:"+Thread.currentThread().getName());
}
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void signal(){
try{
lock.lock();
this.condition.signal();
System.out.println("唤醒了一个线程");
}finally {
lock.unlock();
}
}
}
MyThread.java不变
test.java:先让线程全部阻塞,然后调用自定义的signal方法唤醒线程,
package 第四章; public class test {
public static void main(String[] args){
MyThread[] threads = new MyThread[5];
MyService myService = new MyService();
for(int i=0;i<5;i++){
threads[i] = new MyThread(myService);
threads[i].start();
}
try{
Thread.sleep(1000);
myService.signal();
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
运行结果如下:
可以看到,我们成功唤醒了一个线程。
下面的例子唤醒了一个指定的线程
MyService.java:根据当前线程的名字让指定的Condition对象等待,并书写两个唤醒不同的Condition对象注册的线程
package 第四章;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
public class MyService {
private Lock lock = new ReentrantLock();
public Condition conditionA = lock.newCondition();
public Condition conditionB = lock.newCondition();
public void testMethod(){
try{
lock.lock();
System.out.println("线程"+Thread.currentThread().getName()+"等待中...");
if(Thread.currentThread().getName().equals("A"))
conditionA.await();
else
conditionB.await();
for(int i=0;i<2;i++){
System.out.println(i+"线程:"+Thread.currentThread().getName());
}
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void signalA(){
try{
lock.lock();
this.conditionA.signal();
System.out.println("唤醒了A线程");
}finally {
lock.unlock();
}
}
public void signalB(){
try{
lock.lock();
this.conditionB.signal();
System.out.println("唤醒了B线程");
}finally {
lock.unlock();
}
}
}
test.java,启动A,B两个线程,只唤醒A线程
package 第四章; public class test {
public static void main(String[] args){
MyService myService = new MyService();
MyThread myThreadA = new MyThread(myService);
myThreadA.setName("A");
MyThread myThreadB = new MyThread(myService);
myThreadB.setName("B");
myThreadA.start();
myThreadB.start();
try{
Thread.sleep(1000);
myService.signalA();
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
运行结果:
根据代码,我们可以看到可以通过不同Condition对象来唤醒指定的线程。
用处:
1.可以想到,如果用Lock来解决之前的多消费多生产者时的假死问题,我们可以将生产者统一注册一个Condition,消费者统一注册一个Condition,每一次唤醒对方的Condition,这样子就不会出现连续唤醒同类导致假死的情况了,并且可以避免唤醒所有线程,导致效率低下。
2.我们也可以按照我们想要的顺序进行唤醒,只要你注册了正确的Condition对象
公平锁和非公平锁:
比较好理解,公平锁相当于一个队列,先进先出,先运行的线程先拿到锁,后运行的后拿到锁,按照顺序来,非公平锁就是锁的抢占是随机的,没有顺序。
默认是非公平锁,创建Lock时加上true参数即为公平锁:
Lock lock =new ReentrantLock(true);
下面介绍一些ReentrantLock的api,
一般在一些定制化的情况可能会用到,emmm,这块先了解一下,知道有这些就行,emmm,说实话目前我感觉这个没啥用,有个印象,不过注意使用这些API使,必须以下面这种方式new对象
ReentrantLock lock = new ReentrantLock();
(lock.)GetHoldCount():查询当前线程有保持着几个lock锁,简单来讲就是当前线程调用了几次lock()方法
GetQueueLength():有多少个线程在等待获取当前锁,可以理解为有多少个没有拿到当前锁,
getWaitQueueLength(Condition condition):有多少个线程处于阻塞状态,并且是执行了参数Condition对象所对应的await()方法导致阻塞的。
hasQueuedThread(Thread thread):查询指定的线程是否正在等待获取当前锁
hasQueuedThreads():查询是否有线程正在等待获取当前锁
hasWaiters(Condition):查询是否有线程是由于调用了参数Condition.await()导致阻塞的。
isHeldByCurrentThread():查询当前线程是否持有当前锁
isLocked():当前锁是否被某个线程持有
awaitUninterruptibly():这也是一种让当前线程阻塞的方法,不过await调用之后如果再使用Interrupt等代码阻塞当前进程会报异常,但是这个不会,相当于让当前线程变成可以阻塞的线程,,,,不懂有撒用
awaitUntil(Date):阻塞当前线程,如果在指定时间之前还没有被唤醒,则唤醒他。参数也可以传Calendar.getTime(),Calendar类用于处理时间
ReentrantReadWriteLock类
之前的ReentrantLock相当于同一时间只有一个线程在执行代码。但是在不涉及更改实例变量的代码之中,我们可以允许异步运行来加快效率, 而一些涉及到更改实例变量的代码,这时候同步执行(这时候异步可能出现非线程安全),这样可以在一定程度上加快效率,这就是这个类的作用。
简单来说,我们一般有读写两个操作,如果多个线程执行读操作,ok,异步执行,如果多个线程有的执行读,有的写,ok,同步执行,这个类就是自动完成这个事情,你只需要在锁时使用不同类型的锁就行。
下面是一个例子,读读异步(其他全部同步):
ReadAndWrite.java 代表具体的操作,读,写,输出当前操作以及时间,sleep()模拟操作耗费的时间
package 第四章; import java.util.concurrent.locks.ReentrantReadWriteLock; public class ReadAndWrite {
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public void read(){
try{
lock.readLock().lock();
System.out.println("读操作"+System.currentTimeMillis());
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.readLock().unlock();
}
}
public void write(){
try{
lock.writeLock().lock();
System.out.println("写操作"+System.currentTimeMillis());
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.writeLock().unlock();
}
}
}
MyThread2.java:里面有两个java类,一个执行读操作,一个写操作
package 第四章; class MyThreadRead extends Thread{
private ReadAndWrite readAndWrite; public MyThreadRead(ReadAndWrite readAndWrite) {
this.readAndWrite = readAndWrite;
} public void run(){
this.readAndWrite.read();
}
}
class MyThreadWrite extends Thread{
private ReadAndWrite readAndWrite; public MyThreadWrite(ReadAndWrite readAndWrite) {
this.readAndWrite = readAndWrite;
} public void run(){
this.readAndWrite.write();
}
}
test.java: 创建三个读线程
package 第四章; public class test {
public static void main(String[] args){
ReadAndWrite readAndWrite = new ReadAndWrite();
MyThreadRead reads[] = new MyThreadRead[3];
for(int i=0;i<3;i++) {
reads[i] = new MyThreadRead(readAndWrite);
reads[i].start();
}
}
}
运行结果:
可以看到,三个读操作时同时执行的。
下面更改test.java,创建三个读线程,三个写线程:
test.java
package 第四章; public class test {
public static void main(String[] args){ ReadAndWrite readAndWrite = new ReadAndWrite();
MyThreadWrite writes[] = new MyThreadWrite[3];
for(int i=0;i<3;i++) {
writes[i] = new MyThreadWrite(readAndWrite);
writes[i].start();
}
MyThreadRead reads[] = new MyThreadRead[3];
for(int i=0;i<3;i++) {
reads[i] = new MyThreadRead(readAndWrite);
reads[i].start();
} }
}
运行:
可以看到,写操作之间是互斥的,相当于同步,一个一个执行的,读的时候就是异步的,
,,好嘞,就演示这几个,其他的都同理,只有读读是异步的,读写同步,你可以交替着start看一下,如下:
好滴,第四章就这些暂时。。
(四)Lock,ReentrantLock,ReentrantReadWriteLock类的使用以及相关api---synchronized进阶的更多相关文章
- 高并发第十一弹:J.U.C -AQS(AbstractQueuedSynchronizer) 组件:Lock,ReentrantLock,ReentrantReadWriteLock,StampedLock
既然说到J.U.C 的AQS(AbstractQueuedSynchronizer) 不说 Lock 是不可能的.不过实话来说,一般 JKD8 以后我一般都不用Lock了.毕竟sychronize ...
- Java Lock ReentrantLock ReentrantReadWriteLock
Lock与Synchronized的区别: 1)Lock是一个接口,而synchronized是Java中的关键字,synchronized是内置的语言实现: 2)synchronized在发生异 ...
- ReentrantLock修饰类文件,实现按类获取锁的逻辑
1.ReentrantLock 给类文件加锁,实现类似synchronized(class)的功能 核心是类文件中,使用static修饰的reentrantLock对象 public class So ...
- ReentrantReadWriteLock类和ReentrantLock类的区别
Java.util.concurrent.locks包定义了两个锁类,ReentrantLock和ReentrantReadWriteLock类. 当有很多线程都从某个数据结构中读取数据而很少有线程对 ...
- 多线程编程学习四(Lock 的使用).
一.前言 本文要介绍使用Java5中 Lock 对象,同样也能实现同步的效果,而且在使用上更加方便.灵活,主要包括 ReentrantLock 类的使用和ReentrantReadWriteLock ...
- concrrent类下ReentrantReadWriteLock类的原理以及使用
1.ReentrantreadWriteLock 类的介绍 Lock接口下的子类存在 ReentrantLock子类,该子类是一个线程同步处理类:ReentrantLock类的介绍详见XXX: Loc ...
- Java多线程核心技术(四)Lock的使用
本文主要介绍使用Java5中Lock对象也能实现同步的效果,而且在使用上更加方便. 本文着重掌握如下2个知识点: ReentrantLock 类的使用. ReentrantReadWriteLock ...
- .net之工作流工程展示及代码分享(四)主控制类
现在应该讲主控制类了,为了不把系统弄得太复杂,所以就用一个类作为主要控制类(服务类),作为前端.后端.业务逻辑的控制类. WorkflowService类的类图如下: 该类的构造函数: public ...
- delphi 线程教学第四节:多线程类的改进
第四节:多线程类的改进 1.需要改进的地方 a) 让线程类结束时不自动释放,以便符合 delphi 的用法.即 FreeOnTerminate:=false; b) 改造 Create 的参数 ...
随机推荐
- Ubuntu 18.04 root 使用ssh密钥远程登陆
前言: Ubuntu默认是禁止root用户远程登陆 本教程解决Ubuntu 18.04版本 root用户 使用ssh密钥无法远程登陆的问题 问题发生的环境: 腾讯云,重装Ubuntu服务器时选择使用s ...
- HiLoGenerator生成id
using System.Linq; namespace Product.Host { public class HiLoGenerator { ; ; ; private object Sequen ...
- Jira 使用手册
Date Revision version Description author 2018-06-14 V1.0.0 Isaac Zhang 2018-06-22 V1.0.1 1,添加git提交操作 ...
- Git的使用和配置小白必看都是干货,为您解惑
Git安装 首先下载git这个软件,然后打开码云新建仓库 在本地选择一个路径作为本地仓库 点新建仓库然后输入邮箱和密码,然后进行配置 在要作为本地仓库的地方新建一个文件夹,保存后关闭,在文件夹空白处鼠 ...
- 个人永久性免费-Excel催化剂功能第104波-批量选择多种类型的图形对象
在Excel的日常操作过程中,选择绝对是一个高频的操作,之前开发过一些快速选择单元格区域的辅助功能,除了单元格区域,Excel强大之处在于,类似PhotoShop那般可以存放多种图形,并且有图层先后顺 ...
- 在Ubuntu中安装Docker和docker的使用
1.在Ubuntu中安装Docker 更新ubuntu的apt源索引 sudo apt-get update 安装包允许apt通过HTTPS使用仓库 sudo apt-get install \ ap ...
- 【git】Git的使用
一.安装git 1.windows下安装一个Git 2.lInux下yum(apt-get) install git 二.使用git连接github 使用git连接github时,需要将linux下产 ...
- 7月新的开始 - LayUI的基本使用 - Tab选项卡切换显示对应数据
LayUI tab选项卡+page展示 要求:实现tab选项卡改变的同时展示数据也跟着改变 实现条件: 1. 选项卡 [官网 – 文档/示例 – 页面元素 – 选项卡] 2.数据表格 [官网 – 文档 ...
- C++多小球非对心弹性碰撞(HGE引擎)
程序是一个月前完成的,之前一直没正儿八经的来整理下这个程序,感觉比较简单,不过即使简单的东西也要跟大家分享下. 源码下载:http://download.csdn.net/detail/y851716 ...
- spring的jdbcTemplate的使用
转载:http://1358440610-qq-com.iteye.com/blog/1826816 一.首先配置JdbcTemplate: 要使用Jdbctemplate 对象来完成jdbc 操作. ...