java多线程JUC库分析之ReentrantLock
文章目录
锁的应用
- 锁能够解决并发共抢资源的问题,例子如下
public class Test {
private static int sum;
public static void main(String[] args) {
for (int i = 0; i< 100; i++){
Thread t = new Thread(new Calc());
t.start();
}
try{
Thread.sleep(1000);
} catch (Exception e){
e.printStackTrace();
}
System.out.println(sum);
}
static class Calc implements Runnable {
@Override
public void run() {
sum++;
System.out.println(Thread.currentThread().getName() +":"+ sum);
}
}
}启动100个线程对sum进行累加,结果不一定是100,优化,加锁后问题解决
public class Test {
private static volatile int sum;
private static ReentrantLock lock;
public static void main(String[] args) {
lock = new ReentrantLock();
for (int i = 0; i< 100; i++){
Thread t = new Thread(new Calc());
t.start();
}
try{
Thread.sleep(1000);
} catch (Exception e){
e.printStackTrace();
}
System.out.println(sum);
}
static class Calc implements Runnable {
@Override
public void run() {
lock.lock();
sum++;
lock.unlock();
System.out.println(Thread.currentThread().getName() +":"+ sum);
}
}
}题外话:上述例子还有一个细节就是,volatile ,没有volatile ,不影响最终结果,但是线程打印的值有重复。这里验证类volatile的可见性,一个线程修改,其他线程立即可见。
- 锁的Condition,condition是条件,用于共同完成一项作业,需要协作的场景。
例子,产生随机数,打印随机数,先产生后打印
public class Test {
private static int random;
private static ReentrantLock lock;
private static Condition condition;
public static void main(String[] args) throws Exception {
lock = new ReentrantLock();
condition = lock.newCondition();
new Thread(new Print()).start();
Thread.sleep(1000);
new Thread(new Generator()).start();
System.out.println("main exit.");
}
static class Print implements Runnable {
@Override
public void run() {
lock.lock();
try {
System.out.println("Print await.");
condition.await();
System.out.println("Print start.");
System.out.println("result is : " + random);
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("Print unlock.");
lock.unlock();
}
}
}
static class Generator implements Runnable {
@Override
public void run() {
lock.lock();
try {
System.out.println("generator start.");
random = (int) (Math.random() * 10000);
System.out.println("generator before signal.");
condition.signal();
System.out.println("generator after signal.");
} finally {
System.out.println("generator unlock.");
try {
Thread.sleep(5000);
} catch (Exception e) {
e.printStackTrace();
}
lock.unlock();
}
}
}
}
锁的实现
- LockSupport类介绍
LockSupport在实现锁的时候,用于挂起和唤醒线程;多线程竞争,只有一个线程获取到锁继续运行,其他线程挂起,待锁释放后,处于队里最前面等待的线程被唤醒,被唤醒不意味着马上获取到锁,而是马上快速尝试取锁。挂起和唤醒的衔接是LockSupport。
public class Test {
private static volatile int sum;
private static ReentrantLock lock;
static class Park implements Runnable {
@Override
public void run() {
park();
}
void park() {
System.out.println("park");
LockSupport.park(this);
System.out.println("out park");
}
}
public static void main(String[] args) {
Thread t = new Thread(new Park());
t.start();
try {
Thread.sleep(3000);
} catch (Exception e) {
e.printStackTrace();
}
LockSupport.unpark(t);
}
}上述演示了LockSupport park和unpark的使用,线程在park处被挂起,直到被其他线程唤醒,唤醒之后从park的下一行代码继续执行。上述例子,是被主线程唤醒。
jstack命令查看
主线程信息
被park的线程信息,名称是Thread-0,
park()和 park(Object blocker)的主要区别是,后者把阻塞信息打印更详细一些,如上图的 “- parking to wait for xxxxx”。blocker是否还有其他用处,待考察。
重要关注点:
看JDK LockSupport.park的方法注释,可以知道,park方法响应线程interrupt,就说,线程被interrupt,会被唤醒。线程被interrupt唤醒后,会把它在等待锁队列Node状态设置成Cancel 1.唤醒特殊情况下会从tail往前遍历原因:
线程释放锁后,调用unparkSuccessor,如果遇到被取消的Node,需要从tail往前遍历。因为如果阻塞队列有多个等待的线程。在锁释放的一瞬间,如果出现unparkSuccessor和等待线程被interrupt并发情形,那么从head往下遍历,不一定能够遍历到有效节点;但是,从tail遍历肯定能够得到有效节点。
为什么从head遍历不一定能够找到有效节点,因为AQS的cancelAcquire会把cancle节点的next设置成,node.next = node;AQS模板设计模式:AQS提供aquire和release 模板方法供子类调用,模板方法中的tryRequire 和tryRelease 供子类调用定制自身逻辑
- ReentrantLock重入锁的实现
重入锁涉及到主要类关系图和lock方法调用图
线程抢占锁、释放锁唤醒同步器队列线程,以及同步器的成员变量head,tail,state变化详细过程如下,用3个线程抢占一把锁开始运行到结束的一次运行过程。

从上述看,可知,假如在线程1释放锁,在唤醒线程2之前,突然有个线程4抢占到锁。这时线程2醒了之后是抢不到锁的。这种谁先抢到是谁的,称之为“不公平锁”,重入锁还支持“公平锁”,公平锁就是谁等待最久,那么优先给谁。具体实现可以看源码,默认的重入锁是“不公平锁”。从效率上来看,“不公平锁”效率高一些。
ReentrantLock重入锁的Condition实现
Condition条件队列,一个线程只有先获取lock 才能进入执行condition.await, await动作把线程放到条件队列,然后把lock释放掉,进入park让出cpu。
condition.signal,把条件队列的线程放入同步队列,然后释放lock,unpark同步队列上的线程。
condition不能单独使用,必须配合lock使用,事实上,condition出现是为了多线程协调配合工作需要,比如,生产者消费者模式,消费者线程的输入是生产者线程的输出,因此两个线程运行是有条件的,需要协调的。如果两个线程互相独立,那么就不需要用锁和condition了。那么为什么condition必须要lock配合,因为生产者和消费者,不能同时运行,因此需要锁,只有获取锁的一方可以运行。生产者获取锁后,生产出东西,释放锁。让消费者去消费。这种场景用lock lock可以,但是消费者消费完后,如何让生产者接着生存,这就需要通知,condition就是这样应运而生的。
如下是消费者和生产者一次交互过程

需要说明序号并不是严格是运行顺序,比如4释放锁后,5和6是并行的,不能确定谁先谁后。
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论