AQS基本概念和自定义锁

1.概念

全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步工具的框架。
特点：

1. 用 state 属性来表示资源和状态 （分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取锁和释放锁。
   1. getState - 获取 state 状态
   2. setSatae - 设置 state 状态
   3. compareAndSetState - 乐观锁机制设置state状态
   4. 独占模式是只有一个线程能够访问资源，而共享模式可以允许多个线程访问资源
2. 提供了基于**FIFO（先进先出）**的等待队列，类似于 **Monitor **的 EntryList
3. 条件变量来实现等待，唤醒机制，支持多个条件变量，类似于**Monitor **的 WaitSet

子类主要实现这样一些方法（默认抛出 UnsupportedOperationException）

• tryAcquire
• tryRelease
• tryAcquireShared
• tryReleaseShared
• isHeldExclusively

获取锁的方式

//如果获取锁失败
if(!tryAcquire(arg)){
    //入队，可以选择阻塞当前线程  park  unpark
}

释放锁的方式

//如果释放锁成功
if(tryRelease(arg)){
    //让阻塞线程恢复运行
}

自定义锁

package com.jie.demo;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class TestAqs {

    public static void main(String[] args) {
        MyLock lock = new MyLock();
        new Thread(()->{
            lock.lock();
            try {
                log.info("加锁成功");
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                log.info("unlock............");
                lock.unlock();
            }
        },"t1").start();

        new Thread(()->{
            lock.lock();
            try {
                log.info("加锁成功");
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                log.info("unlock............");
                lock.unlock();
            }
        },"t2").start();
    }

}

//自定义锁（不可重入锁）
class MyLock implements Lock {

    // 独占锁  同步器类
    class MySync extends AbstractQueuedSynchronizer {
        @Override
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0, 1)) {
                //加上了锁,并设置 owner 是当前线程
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }

            return false;
        }

        @Override //解锁
        protected boolean tryRelease(int arg) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }


        @Override // 是否持有独占锁
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }

        public Condition newCondition() {
            return new ConditionObject();
        }

    }

    private MySync sync = new MySync();

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