java concurrent之ReentrantLock
在编码的过程中。有时候我们不得不借助锁同步来保证线程安全。synchronizedkeyword在上一篇博客中已经介绍。自从JDK5開始,加入了还有一种锁机制:ReentrantLock。
二者的差别
1、lock是jdk5之后代码层面实现的,synchronized是JVM层面实现的。
2、synchronized在出现异常的时候可以自己主动释放锁。而lock必须在finally块中unlock()主动释放锁。否则会死锁。
3、在竞争不激烈的时候synchronized的性能是比lock好一点的。可是当竞争非常激烈时synchronized的性能会相对几十倍的下降,由于lock用了新的锁机制,新的Lock机制终于归结到一个原子性操作上。
4、synchronized无法中断一个正在等候获得锁的线程。也无法通过投票得到锁,假设不想等下去,也就没法得到锁;而lock能够。
5、ReentrantLock能够採用FIFO的策略进行竞争,更加公平。
基本使用方法
先写个简单的样例看一下:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class TestReentrantLock {
public static void main(String[] args) {
final ReentrantLock rLock = new ReentrantLock();
final Condition condition = rLock.newCondition();
ExecutorService executorService = Executors.newFixedThreadPool(5);
Runnable opt = new Runnable() {
@Override
public void run() {
rLock.lock();
System.out.println(Thread.currentThread().getName()+"--->>lock()");
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println(Thread.currentThread().getName()+"--->>unlock()");
rLock.unlock();
}
}
}; for (int i = 0; i < 4; i++) {
executorService.submit(opt);
} Runnable release = new Runnable() {
@Override
public void run() {
rLock.lock();
try {
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName()+"--->>signalAll()");
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
rLock.unlock();
}
}
};
executorService.submit(release);
executorService.shutdown();
}
}
执行结果:
pool-1-thread-1--->>lock()
pool-1-thread-2--->>lock()
pool-1-thread-3--->>lock()
pool-1-thread-4--->>lock()
pool-1-thread-5--->>signalAll()
pool-1-thread-1--->>unlock()
pool-1-thread-2--->>unlock()
pool-1-thread-3--->>unlock()
pool-1-thread-4--->>unlock()
上面代码中有个Condition,它的三个方法await 、 signal 和 signalAll,与基类的wait、notify和notifyAll方法相相应,由于它们不能覆盖Object上的相应方法。所以就起了这三个奇葩的名字。由上面的代码能够看出ReentrantLock和synchronized使用方法是基本同样的。
中断ReentrantLock
实比例如以下:
package co.etc.concurrent;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockSample {
public static void main(String[] args) {
testReentrantLock();
}
public static void testReentrantLock() {
final SampleSupportLock support = new SampleSupportLock();
Thread first = new Thread(new Runnable() {
public void run() {
try {
support.doSomething();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread second = new Thread(new Runnable() {
public void run() {
try {
support.doSomething();
} catch (InterruptedException e) {
System.out.println("InterruptedException--->>");
}
}
});
executeTest(first, second);
}
public static void executeTest(Thread a, Thread b) {
a.start();
try {
Thread.sleep(100);
b.start();
Thread.sleep(1000);
System.out.println("---->>>interrupt()");
b.interrupt();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
abstract class SampleSupport {
protected int counter;
public void startTheCountdown() {
long currentTime = System.currentTimeMillis();
for (;;) {
long diff = System.currentTimeMillis() - currentTime;
if (diff > 2000) {
break;
}
}
}
}
class SampleSupportLock extends SampleSupport {
private final ReentrantLock lock = new ReentrantLock();
public void doSomething() throws InterruptedException {
lock.lockInterruptibly();
System.out.println(Thread.currentThread().getName()
+ "doSomething()--->>");
startTheCountdown();
try {
counter++;
} finally {
lock.unlock();
}
System.out.println("counter---->>>"+counter);
}
}
执行结果:
Thread-0doSomething()--->>
---->>>interrupt()
InterruptedException--->>
counter---->>>1
执行结果表明第二个线程被中断了,这是由于我用的是lock.lockInterruptibly();在主线程中我调用了b.interrupt();二synchronized是没法做到的
公平性
实例代码例如以下:
import java.util.Collection;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TestFairLock {
private static Lock fairLock = new ReentrantLock2(true);
private static Lock unfairLock = new ReentrantLock2();
public static void main(String[] args) {
TestFairLock testFairLock = new TestFairLock();
// testFairLock.unfair();
testFairLock.fair();
}
public void fair() {
System.out.println("fair version");
for (int i = 0; i < 5; i++) {
Thread thread = new Thread(new Job(fairLock)) {
public String toString() {
return getName();
}
};
thread.setName("" + i);
thread.start();
}
// sleep 5000ms
}
public void unfair() {
System.out.println("unfair version");
for (int i = 0; i < 5; i++) {
Thread thread = new Thread(new Job(unfairLock)) {
public String toString() {
return getName();
}
};
thread.setName("" + i);
thread.start();
}
// sleep 5000ms
}
private static class Job implements Runnable {
private Lock lock;
public Job(Lock lock) {
this.lock = lock;
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
lock.lock();
try {
System.out.println("Thread--->>"
+ Thread.currentThread().getName());
} finally {
lock.unlock();
}
}
}
}
private static class ReentrantLock2 extends ReentrantLock {
private static final long serialVersionUID = 1773716895097002072L;
public ReentrantLock2(boolean b) {
super(b);
}
public ReentrantLock2() {
super();
}
public Collection<Thread> getQueuedThreads() {
return super.getQueuedThreads();
}
}
}
执行结果
unfair version
Thread--->>0
Thread--->>0
Thread--->>0
Thread--->>0
Thread--->>0
Thread--->>1
Thread--->>1
Thread--->>1
Thread--->>1
Thread--->>1
Thread--->>2
Thread--->>2
Thread--->>2
Thread--->>2
Thread--->>2
Thread--->>3
Thread--->>3
Thread--->>3
Thread--->>3
Thread--->>3
Thread--->>4
Thread--->>4
Thread--->>4
Thread--->>4
Thread--->>4
fair version
Thread--->>0
Thread--->>0
Thread--->>1
Thread--->>3
Thread--->>0
Thread--->>4
Thread--->>2
Thread--->>1
Thread--->>3
Thread--->>0
Thread--->>4
Thread--->>2
Thread--->>1
Thread--->>3
Thread--->>0
Thread--->>4
Thread--->>2
Thread--->>1
Thread--->>3
Thread--->>4
Thread--->>2
Thread--->>1
Thread--->>3
Thread--->>4
Thread--->>2
从执行结果看到用ReentrantLock(boolean fair)构建的锁,相对ReentrantLock()是更公平的,当fair为true时採用的是FIFO策略,所
以各个线程可以更平均的分配时间。
java concurrent之ReentrantLock的更多相关文章
- java中的 java.util.concurrent.locks.ReentrantLock类中的lockInterruptibly()方法介绍
在java的 java.util.concurrent.locks包中,ReentrantLock类实现了lock接口,lock接口用于加锁和解锁限制,加锁后必须释放锁,其他的线程才能进入到里面执行, ...
- java中的 java.util.concurrent.locks.ReentrantLock类的使用方式
实现了lock的类为:ReentrantLock 接口的方式解释: lock()方法为获取锁对象,如果未获取到锁就一直获取锁. trylock():为布尔值,返回是否获取到了锁,如果没有获取到锁则返回 ...
- java Concurrent包学习笔记(三):ReentrantLock
一.可重入性的理解 从名字上理解,ReenTrantLock的字面意思就是再进入的锁,其实synchronized关键字所使用的锁也是可重入的,两者关于这个的区别不大.两者都是同一个线程每进入一次,锁 ...
- Java并发控制:ReentrantLock Condition使用详解
生产者-消费者(producer-consumer)问题,也称作有界缓冲区(bounded-buffer)问题,两个进程共享一个公共的固定大小的缓冲区.其中一个是生产者,用于将消息放入缓冲区:另外一个 ...
- java concurrent包的学习(转)
java concurrent包的学习(转) http://my.oschina.net/adwangxiao/blog/110188 我们都知道,在JDK1.5之前,Java中要进行业务并发时,通常 ...
- [Java Concurrent] 并发访问共享资源的简单案例
EvenGenerator 是一个偶数生成器,每调用一个 next() 就会加 2 并返回叠加后结果.在本案例中,充当被共享的资源. EvenChecker 实现了 Runnable 接口,可以启动新 ...
- Java并发之ReentrantLock
一.ReentrantLock简介 ReentrantLock字面意义上理解为可重入锁.那么怎么理解可重入这个概念呢?或者说和我们经常用的synchronized又什么区别呢? ReentrantLo ...
- java并发之ReentrantLock学习理解
简介 java多线程中可以使用synchronized关键字来实现线程间同步互斥,但在jdk1.5中新增加了ReentrantLock类也能实现同样的效果,并且在扩展功能上也更加强大,比如具有嗅探锁定 ...
- Java并发编程-ReentrantLock源码分析
一.前言 在分析了 AbstractQueuedSynchronier 源码后,接着分析ReentrantLock源码,其实在 AbstractQueuedSynchronizer 的分析中,已经提到 ...
随机推荐
- JQuery缓冲加载图片插件lazyload.js的使用方法
lazyload.js是一个基于JQuery的插件,可以用来缓冲加载图片.如果一个网页很长并且有很多图片的话,下载图片就需要很多时间,那么就会影响整个网页的加载速度,而这款延迟加载插件,会通过你的滚动 ...
- 校验IPv4和IPv6地址和URL地址
1.校验IPV4地址: function validateIp(obj) { var ip=$(obj).val(); var re=/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/;// ...
- Redis自学笔记—PHP
connect 实例连接到一个Redis. $redis = new redis(); $result = $redis->connect('127.0.0.1', 6379); var_dum ...
- (转)Unity3D - 性能优化之Draw Call
Unity(或者说基本所有图形引擎)生成一帧画面的处理过程大致可以这样简化描述:引擎首先经过简单的可见性测试,确定摄像机可以看到的物体,然后把这些物体的顶点(包括本地位置.法线.UV等),索引(顶点如 ...
- Compiling LIBFFM On OSX 10.9
原文:http://blog.josephmisiti.com/compiling-libffm-on-osx-10.9/ I recently tried to compile LIBFFM (Fi ...
- 内容匹配广告投放技术4:网盟CTR预估(百度文库课程)
原文:http://wbj0110.iteye.com/blog/2043065 该文是百度文库课程<计算广告学之内容匹配广告&展示广告原理.技术和实践>的课程笔记,感谢百度! 课 ...
- google/protobuf/releases/tag/v3.4.0 下载
Protocol Buffers v3.4.0 Downloads 4.07 MB protobuf-cpp-3.4.0.tar.gz 5.02 MB protobuf-cpp-3.4.0.zip 4 ...
- ubuntu server 安装 mantis bug tracker 中文配置
ubuntu server 安装 mantis bug tracker 中文配置 官网:http://www.mantisbt.org/ 一:安装: 1:进入到 apache2的网站目录: cd /v ...
- wepy - 与原生有什么不同(slot插槽)
wepy官方文档是这样介绍的 简单描述就是: index.wpy:子组件 panel.wpy:父组件 1.slot是内容分发的占位符 2.slot父组件在子组件使用时,名称必须一致 3.slot子组件 ...
- Hibernate(八)多对多映射
一.创建数据表 --学生证表 create table paper ( pid number primary key, pdesc ) , sid number references student( ...