一、AbstractQueuedSynchronizer就不多说了,Lock就是基于它来实现锁的功能的,而AbstractQueuedSynchronizer底层则是通过cas操作来实现。
通过AbstractQueuedSynchronizer来实现共享锁其实很简单,只需要对AbstractQueuedSynchronizer的状态进行控制就行了,其他的AbstractQueuedSynchronizer都做好了封装,举个例子吧。
package com.pinnet.test;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
public class ShareLock implements Lock {
private Syn sync = new Syn(5);
/**
* 在同步装置内部实现一个AbstractQueuedSynchronizer的子类
*
*/
private static final class Syn extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 5854536238831876527L;
//构造方法,同时进入的线程数量必须为整数
Syn(int count) {
if (count <= 0) {
throw new IllegalArgumentException("count must large than zero.");
}
//设置AQS的状态为count
setState(count);
}
/**
* 加锁的时候会调用此方法,redececount参数为改变的状态数量,一般传1即可
*/
public int tryAcquireShared(int reduceCount) {
//加锁和释放的方法都必须要放在循环中,避免失败的操作
for (;;) {
//获取当前的状态
int current = getState();
//计算过后的状态
int newCount = current - reduceCount;
//如果新的状态小于0 则返回值,在AQS的doAcquireShared方法中,如果返回的值小于0,则会将该线程封装为node放入队列
//如果大于0 表示该线程能执行则线程会继续执行不受影响
if (newCount < 0 || compareAndSetState(current, newCount)) {
return newCount;
}
}
}
public boolean tryReleaseShared(int retrunCount) {
for (;;) {
int current = getState();
int newCount = current + retrunCount;
if (compareAndSetState(current, newCount)) {
return true;
}
}
}
}
public void lock(){
sync.acquireShared(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 void unlock(){
sync.releaseShared(1);
}
public Condition newCondition(){
return null;
}
}
注释很清楚,具体的可以看AbstractQueuedSynchronizer实现,其实都是很简单地