我们已经了解了AQS的的基本原理了，不如自己仿照其它锁实现一个排他锁吧。
要求如下：同一时间只允许一个线程持有锁，不要求可重入(反复加锁直接忽视即可)。
(1)实现Lock接口
代码语言：javascript复制public class Demo23 {
public static void main(String[] args) {
}
private static class myLock implements Lock{
@Override
public void lock() {
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public boolean tryLock() {
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public void unlock() {
}
@Override
public Condition newCondition() {
return null;
}
}
}(2) 创建内部类sync继承AQS，内部调用sync完成逻辑
代码语言：javascript复制public class Demo23 {
public static void main(String[] args) {
myLock lock = new myLock();
lock.lock();
}
private static class myLock implements Lock{
private class sync extends AbstractQueuedSynchronizer {
@Override
protected boolean tryAcquire(int arg) {
return super.tryAcquire(arg);
}
@Override
protected boolean isHeldExclusively() {
return getExclusiveOwnerThread() == Thread.currentThread();
}
protected Condition newCondition() {
return new ConditionObject();
}
}
sync sync = new sync();
@Override
public void lock() {
sync.acquire(1);
}
@Override
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
@Override
public boolean tryLock() {
return sync.tryAcquire(1);
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(time));
}
@Override
public void unlock() {
sync.release(1);
}
@Override
public Condition newCondition() {
return sync.newCondition();
}
}
}上面代码的运行结果如下。
代码语言：javascript复制/home/wangzhou/IdeaProjects/jucdemo/src/com/wangzhou/Demo21.java:11:24
java: 未报告的异常错误java.lang.InterruptedException; 必须对其进行捕获或声明以便抛出这是因为其父类的tryAcquire方法实现如下。
代码语言：javascript复制 protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}(3)实现tryAcquire 先看看其它锁怎么做的。比如公平锁。
代码语言：javascript复制 protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}上面代码包含可重入逻辑，我们这里如果重入直接忽略，返回false，因此核心逻辑就只需要进行一个CAS操作了。
@Override
protected boolean tryAcquire(int acquires) {
if(isHeldExclusively()) {
return true;
}
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}加锁过程已经完成，您可以自行测试，接下来我们来实现解锁功能。
同样先看看其它锁怎么实现。
代码语言：javascript复制 protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}我们要实现的逻辑也很简单，没加锁的情况下不允许解锁。加锁的情况下解锁。
代码语言：javascript复制 @Override
protected boolean tryRelease(int args) {
if(getState() == 0) {
throw new UnsupportedOperationException();
}
if(isHeldExclusively()) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
return false;
}测试.
代码语言：javascript复制public static void main(String[] args) throws InterruptedException {
myLock lock = new myLock();
lock.lock();
new Thread(() ->{
lock.lock();
System.out.println("thread2 get lock");
lock.unlock();
}).start();
TimeUnit.SECONDS.sleep(1);
lock.unlock();
System.out.println("thread 1 unlock");
}
condition请读者自测。
