理解aqs并通过重写aqs写一个自定义独占锁和共享所

概念理解参考：https://blog.csdn.net/weixin_40921797/article/details/84553820

自定义的独占式可重入同步工具类

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 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();
}

}

 

自定义的三元共享同步工具类

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) {
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();
}
}

 

转载于:https://www.cnblogs.com/JdestinationL/p/10559146.html