java 队列同步器AbstractQueuedSynchronizer（AQS）

 

队列同步器AbstractQueuedSynchronizer（AQS），是用来构建锁或者其他同步组件的基础框架如对获取锁失败线程的阻塞、唤醒，都是AQS替我们实现，ReentrantLock，ReentrantReadWriteLock和CountDownLatch等都是用AQS实现的。

队列同步器AbstractQueuedSynchronizer:

1. 内部使用一个int变量state表示同步状态。
2. 内部使用一个隐式的FIFO队列(并没有声明这样一个队列，只是通过每个节点记录它的上下节点来从逻辑上产生一个队列)来完成阻塞线程的排队。
3. 同步器提供的3个方法getState()、setState(int newState)和compareAndSetState(int expect,int update)来进行状态操作(三个操作是安全的)。
4. 支持独占锁和共享锁(读所和写锁)
5. 同步器的方法:

      1：可重写的方法

方法名称	描述
boolean tryAcquire(int arg)	独占式获取同步状态，成功返回true，失败返回false。
boolean tryRelease(int arg)	独占式释放同步状态，成功返回true，失败返回false。
int tryAcquireShared(int arg)	共享式获取同步状态，获取成功则返回值>=0
boolean tryReleaseShared(int arg)	共享式释放同步状态，成功返回true，失败返回false。
boolean isHeldExclusively()	判断同步器是否在独占模式下被占用，一般用来表示同步器是否被当前线程占用

 

 

 

 

 

 

     2：设置AQS的同步状态state的方法     

方法	描述
int getState()	获取当前同步状态
void setState(int newState)	设置当前同步状态
boolean compareAndSetState(int expect, int update)	使用CAS设置当前状态，保证状态更新的原子性

 

 

 

 

     3：AQS 提供的模板方法

 

自定义一个简单的独占锁

1. 继承lock接口

2. 构建一个静态内部类继承AQS

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

class TestLock implements Lock {
    // 静态内部类，自定义同步器
    private static class Sync extends AbstractQueuedSynchronizer {
        // 当状态为 0 的时候获取锁
        public boolean tryAcquire(int acquires) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        // 释放锁，将状态设置为0
        protected boolean tryRelease(int releases) {
            // 如果当前线程没有获得锁也就是 getState不为1 直接抛出异常
            if (getState() == 0) throw new
                    IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        // 返回一个Condition，每个condition都包含了一个condition队列
        Condition newCondition() {
            return new ConditionObject();
        }
    }

    // 仅需要将操作代理到Sync上即可
    private final Sync sync = new Sync();

    // 获取锁
    @Override
    public void lock() {
        sync.acquire(1);
    }

    // 尝试获取锁
    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    @Override
    public void unlock() {
        sync.release(1);
    }

    // 可中断的获取锁
    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    // 尝试获取锁
    @Override
    public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

    public Condition newCondition() {
        return sync.newCondition();
    }
}

可以看到我们利用 AQS 构建一个锁是非常简单的 线程的阻塞 状态切换等 都给我们提供了相应方法我们只需要重写几个方法就可以了。