Java学习笔记9-AQS抽象队列同步器

Java学习笔记9-AQS抽象队列同步器

AQS抽象队列同步器

我们看下Lock相关源码发现 JDK内部将一些共性逻辑抽象为AbstractQueuedSynchronizer类,应用模版方法设计模式通过子类实现不同锁的效果。AQS提供了对资源占用、释放,线程的等待、唤醒等接口和具体实现。可以用在各种需要控制资源争用的场景中。(ReentrantLock / CountDownLatch / Semaphore)

AQS内部主体:state,owner,waiters

独占资源接口:acquire、tryAcquire、release、tryRelease

共享资源接口:acquireShared 、tryAcquireShared、releaseShared 、tryReleaseShared

acquire、 acquireShared : 定义了资源争用的逻辑,如果没拿到,则等待。

tryAcquire、 tryAcquireShared : 实际执行占用资源的操作,如何判定一个由使用者具体去实现。

release、 releaseShared : 定义释放资源的逻辑,释放之后,通知后续节点进行争抢。

tryRelease、 tryReleaseShared: 实际执行资源释放的操作,具体的AQS使用者去实现。

下面我们把之前实现的锁抽象一下也写一个简易的AQS类

import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;

public class AqsTest {
    // 当前锁的拥有者
    volatile AtomicReference<Thread> owner = new AtomicReference<>();
    // 等待集合(锁池)
    volatile LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();
    // 记录锁的状态
    volatile AtomicInteger state = new AtomicInteger(0);

    /**
     * 获取独占锁
     */
    public void acquire() {
        boolean addQ = true;
        while (!tryAcquire()) {
            if (addQ) {
                // 没获取到锁,加入到等待集合中
                waiters.offer(Thread.currentThread());
                addQ = false;
            } else {
                // 挂起当前线程,等待其他线程释放
                LockSupport.park(); // 收到 unpark 通知之后唤醒,继续循环
            }
        }
        waiters.remove(Thread.currentThread()); // 从等待集合中移除线程
    }

    /**
     * 释放独占锁
     */
    public void release() {
        if (tryRelease()) {
            // 通知其他等待线程
            Iterator<Thread> iterator = waiters.iterator();
            while (iterator.hasNext()) {
                Thread waiter = iterator.next();
                LockSupport.unpark(waiter); // 唤醒线程继续 抢锁
            }
        }
    }

    /**
     * 获取共享锁
     */
    public void acquireShared() {
        boolean addQ = true;
        while (tryAcquireShared() < 0) {
            if (addQ) {
                // 没获取到锁,加入到等待集合中
                waiters.offer(Thread.currentThread());
                addQ = false;
            } else {
                // 挂起当前线程,等待其他线程释放
                LockSupport.park(); // 收到 unpark 通知之后唤醒,继续循环
            }
        }
        waiters.remove(Thread.currentThread()); // 从等待集合中移除线程
    }

    /**
     * 释放共享锁
     */
    public void releaseShared() {
        if (tryReleaseShared()) {
            // 通知其他等待线程
            Iterator<Thread> iterator = waiters.iterator();
            while (iterator.hasNext()) {
                Thread waiter = iterator.next();
                LockSupport.unpark(waiter); // 唤醒线程继续 抢锁
            }
        }
    }

    /**
     * 获取独占锁逻辑,实际使用者去实现
     *
     * @return
     */
    public boolean tryAcquire() {
        throw new UnsupportedOperationException();
    }

    /**
     * 释放独占锁逻辑,实际使用者去实现
     *
     * @return
     */
    public boolean tryRelease() {
        throw new UnsupportedOperationException();
    }

    /**
     * 获取共享锁逻辑,实际使用者去实现
     *
     * @return
     */
    public int tryAcquireShared() {
        throw new UnsupportedOperationException();
    }

    /**
     * 释放共享锁逻辑,实际使用者去实现
     *
     * @return
     */
    public boolean tryReleaseShared() {
        throw new UnsupportedOperationException();
    }

    public AtomicInteger getState() {
        return state;
    }

    public void setState(AtomicInteger state) {
        this.state = state;
    }
}

我们再把之前自己实现的锁改造一下

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

public class AqsLockTest implements Lock {
    // 抽象工具类AQS
    AqsTest aqs = new AqsTest() {
        @Override
        public boolean tryAcquire() {
            return owner.compareAndSet(null, Thread.currentThread());
        }

        @Override
        public boolean tryRelease() {
            return owner.compareAndSet(Thread.currentThread(), null);
        }
    };

    @Override
    public boolean tryLock() {
        return aqs.tryAcquire();
    }

    @Override
    public void lock() {
        aqs.acquire();
    }

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

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

看看这代码是不是有点意思了~

同步锁的本质 - 排队

同步的方式:独享锁 - 单个队列窗口,共享锁 - 多个队列窗口

抢锁的方式:插队抢(不公平锁)、先来后到抢锁(公平锁)

没抢到锁的处理方式:快速尝试多次(CAS自旋锁)、阻塞等待

唤醒阻塞线程的方式(叫号器):全部通知、通知下一个

资源占用流程
  1. acquire获取资源 --> 2

  2. tryAcquire尝试抢资源 --没抢到资源–> 3

    –抢到资源 --> 5

  3. 加入队列 --park–> 4

  4. 等待 --unpark–> 2

    –interrupt–> 5

  5. end

实现自己的FutureTask

我们实现了几个自己的功能类,虽然有点简易但按照这种方法去分析 JDK源码,模仿并实现自己的类才能更好的了解 JDK原理,下面我们分析特征来实现个自己的FutureTask

import java.util.concurrent.Callable;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.locks.LockSupport;

// 分析特征:构造函数/泛型/Runnable/GET返回结果
public class MyFutureTaskTest<T> implements Runnable {
    Callable<T> callable; //包装了业务逻辑代码
    T result; //线程执行结果
    volatile String state = "NEW"; //任务执行的状态
    // 容器把等待中的线程保存起来 -- 停车场
    LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();

    public MyFutureTaskTest(Callable<T> callable) {
        this.callable = callable;
    }

    // 查询 -- 异步线程要去调用的
    @Override
    public void run() { //线程启动后,会执行run方法
        System.out.println(Thread.currentThread().getName() + "开始执行");
        // 业务逻辑执行
        try {
            result = callable.call();
        } catch (Exception e) {
            //result =
            //state = "EXP"; //异常状态
            e.printStackTrace();
        } finally {
            state = "END";
        }
        System.out.println(Thread.currentThread().getName() + "执行完了");

        // TODO 唤醒等待的线程
        System.out.println("阻塞进程数:" + waiters.size());
        Thread waiter = waiters.poll(); //停车场取数据
        while (waiter != null) {
            System.out.println(waiter.getName() + "解除阻塞");
            LockSupport.unpark(waiter); //唤醒指定的线程 --- waiter
            System.out.println(waiter.getName() + "解除阻塞完毕");
            waiter = waiters.poll(); //停车场取数据
        }

    }

    // 调用 --- 方法执行主线程
    public T get() { //获取返回值
        if ("END".equals(state)) {
            return result;
        } //else if (exception) 抛出异常

        // TODO 等待...如何控制线程的执行(停),需要等待run 这个线程执行完毕
        // 线程不继续执行代码,去什么地方? 正在跑的车 ---> 停车场
        while (!"END".equals(state)) {
            waiters.add(Thread.currentThread());
            System.out.println(Thread.currentThread().getName() + "准备阻塞");
            LockSupport.park(); //当前线程阻塞等待 --- native方法控制 C++底层实现
            System.out.println(Thread.currentThread().getName() + "阻塞完毕");
        }

        return result;
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值