一、AbstractQueuedSynchronizer深入分析
1.1 AQS使用方式和其中的设计模式
继承,模板方法设计模式
其中的方法
模板方法:
独占式获取
accquire
acquireInterruptibly
tryAcquireNanos
共享式获取
acquireShared
acquireSharedInterruptibly
tryAcquireSharedNanos
独占式释放锁
release
共享式释放锁
releaseShared
需要子类覆盖的流程方法
独占式获取 tryAcquire
独占式释放 tryRelease
共享式获取 tryAcquireShared
共享式释放 tryReleaseShared
这个同步器是否处于独占模式 isHeldExclusively
同步状态state:
getState:获取当前的同步状态
setState:设置当前同步状态
compareAndSetState 使用CAS设置状态,保证状态设置的原子性
AQS中使用的模板方法设计模式
package com.AQS;
import java.util.Date;
/**
* 模板方法模式
* 在父类中定义抽象方法,然后再定义一个模板(框架)方法
*/
public abstract class SendCustom {
public abstract void to();
public abstract void from();
public abstract void content();
public void date() {
System.out.println(new Date());
}
public abstract void send();
// 框架方法
public void sendMessage() {
to();
from();
content();
date();
send();
}
}
package com.AQS;
public class SendSms extends SendCustom {
@Override
public void to() {
System.out.println("发送给A");
}
@Override
public void from() {
System.out.println("B发送信息");
}
@Override
public void content() {
System.out.println("hello world");
}
@Override
public void send() {
System.out.println("send SMS");
}
public static void main(String[] args) {
SendCustom sendSms = new SendSms();
sendSms.sendMessage();
}
}
自己实现类似ReentrantLock(独占锁)
package com.AQS;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
/**
* 实现自己的类似ReentrantLock(独占锁)
*/
public class SelfLock implements Lock {
//state 表示获取到锁 state=1 获取到了锁,state=0,表示这个锁当前没有线程拿到
private static class Sync extends AbstractQueuedSynchronizer {
//是否占用
protected boolean isHeldExclusively() {
return getState() == 1;
}
protected boolean tryAcquire(int arg) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int arg) {
if (getState() == 0) {
throw new UnsupportedOperationException();
}
setExclusiveOwnerThread(null);
// 释放锁为什么没有采用原子操作,因为锁只能有一个线程持有,没有其他线程抢着释放锁
setState(0);
return true;
}
Condition newCondition() {
return new ConditionObject();
}
}
private final Sync sycn = new Sync();
@Override
public void lock() {
sycn.acquire(1);
}
@Override
public void lockInterruptibly() throws InterruptedException {
sycn.acquireInterruptibly(1);
}
@Override
public boolean tryLock() {
return sycn.tryAcquire(1);
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return sycn.tryAcquireNanos(1, unit.toNanos(time));
}
@Override
public void unlock() {
sycn.release(1);
}
@Override
public Condition newCondition() {
return sycn.newCondition();
}
}
package com.AQS;
import java.util.concurrent.locks.Lock;
public class SelfLockTest {
public void test() throws InterruptedException {
final Lock selfLock = new SelfLock();
class Worker extends Thread {
public void run() {
while (true) {
selfLock.lock();
try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
selfLock.unlock();
}
}
}
}
// 启动10个子线程
for (int i = 0; i < 5; i++) {
Worker w = new Worker();
w.setDaemon(true);
w.start();
}
// 主线程每隔1秒换行
for (int i = 0; i < 10; i++) {
Thread.sleep(1000);
System.out.println();
}
}
public static void main(String[] args) throws InterruptedException {
SelfLockTest selfLockTest = new SelfLockTest();
selfLockTest.test();
}
}
二、AQS的原理
AQS采用的数据结构-节点和同步队列(先进先出,双向链表)
简单描述:首先同步器有两个指针,一个指向首节点,另外一个指向尾结点。以独占式锁为例,当线程A请求锁时,线程B刚好也请求锁,此时锁被线程A占用着,那就将线程B打包为一个node节点,添加到同步队列,此时线程C也请求锁,发现A还在占用锁,队列中已经有B线程在等待了,然后线程C也会被打包放在线程B的后面。
同步器设置首节点时不需要采用CAS操作,但是设置尾结点是需要采用CAS操作,同步队列里面的线程在等待锁的过程中采用的自旋方式。
java.util.concurrent.locks.AbstractQueuedSynchronizer#acquire(获取锁)
方法tryAcquire(arg)如果拿到锁,就返回true,如果没有拿到锁返回false,然后将使用方法addWaiter(Node.EXCLUSIVE)该线程打包成Node节点,通过acquireQueued(addWaiter(Node.EXCLUSIVE), arg))添加到队列,后续其他代码咨询查看源码。
节点加入到同步队列
首节点的变化
独占式同步状态获取与释放
三、共享式同步状态获取与释放
package com.AQS;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject;
/**
* 三元共享同步工具类
*/
public class TrinityLock {
//为3表示允许两个线程同时获得锁
private final Sync sync = new Sync(3);
private static final class Sync extends AbstractQueuedSynchronizer {
//private static final long serialVersionUID = -7889272986162341211L;
Sync(int count) {
if (count <= 0) {
throw new IllegalArgumentException("count must large than zero.");
}
setState(count);
}
public int tryAcquireShared(int reduceCount) {
// 采用自旋 加上 CAS
for (;;) {
int current = getState();
int newCount = current - reduceCount;
if (newCount < 0 || compareAndSetState(current, newCount)) {
return newCount;
}
}
}
public boolean tryReleaseShared(int returnCount) {
for (;;) {
int current = getState();
int newCount = current + returnCount;
if (compareAndSetState(current, newCount)) {
return true;
}
}
}
final ConditionObject newCondition() {
return new ConditionObject();
}
}
public void lock() {
sync.acquireShared(1);
}
public void unlock() {
sync.releaseShared(1);
}
public void lockInterruptibly() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public boolean tryLock() {
return sync.tryAcquireShared(1) >= 0;
}
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(time));
}
public Condition newCondition() {
return sync.newCondition();
}
}
三、Condition分析
一个锁可以有多个Condition
同步队列与等待队列
节点在队列之间的移动
await()
signal()
待补充:await(),signal()方法的区别