AQS(AbstractQueuedSynchronizer)同步器

最新推荐文章于 2024-04-19 21:15:28 发布

脱氨垃圾

最新推荐文章于 2024-04-19 21:15:28 发布

阅读量90

点赞数

分类专栏： J.U.C 文章标签： java

本文链接：https://blog.csdn.net/qq_36109528/article/details/120672744

版权

J.U.C 专栏收录该内容

54 篇文章 0 订阅

订阅专栏

AQS(AbstractQueuedSynchronizer)同步器

文章目录

AQS(AbstractQueuedSynchronizer)同步器
- 1.概述
- 2.自定义实现不可重入锁

1.概述

AQS全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步器工具的框架 .

AQS的几种状态:

/** waitStatus value to indicate thread has cancelled */
//1:线程已经获得锁
static final int CANCELLED =  1;
/** waitStatus value to indicate successor's thread needs unparking */
//-1 :唤醒后继节点
static final int SIGNAL    = -1;
/** waitStatus value to indicate thread is waiting on condition */
//-2 :在条件变量中
static final int CONDITION = -2;
/**
 * waitStatus value to indicate the next acquireShared should
 * unconditionally propagate
 */
static final int PROPAGATE = -3;

特点:

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

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

tryAcquire 尝试获得锁
tryRelease 尝试释放锁
tryAcquireShared
tryReleaseShared
isHeldExclusively 判断是否获得锁

获取锁

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

释放锁

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

2.自定义实现不可重入锁

要继承Lock接口实现自己的锁,要使用AQS实现自己的同步器.

自定义不可重入锁代码

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

    /**
     * 自定义AQS同步器
     */
    static class MySync extends AbstractQueuedSynchronizer {
        //获得锁
        @Override
        protected boolean tryAcquire(int arg) {
            if (arg == 1) {
                //此处不能用1次if判断,要用do...while做CAS操作
//                if (compareAndSetState(0, 1)) {
//                    setExclusiveOwnerThread(Thread.currentThread());
//                    setState(1);
//                    return true;
//                }
                do{

                }while(!compareAndSetState(0, 1));
                setExclusiveOwnerThread(Thread.currentThread());
                setState(1);
                return true;
            }
            return false;
        }

        //释放锁
        @Override
        protected boolean tryRelease(int arg) {
            if (arg == 1) {
                if (getState() == 0) {
                    throw new IllegalMonitorStateException();
                }
                setExclusiveOwnerThread(null);
                setState(0);
                return true;
            }
            return false;
        }

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

        //获取条件变量
        protected Condition newCondition() {
            return new ConditionObject();
        }
    }

    private static MySync mySync = new MySync();

    @Override
    public void lock() {
        mySync.tryAcquire(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        mySync.acquireInterruptibly(1);
    }

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

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return mySync.tryAcquireNanos(1, unit.toNanos(time));
    }

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

    @Override
    public Condition newCondition() {
        return mySync.newCondition();
    }
}

---------------测试代码-----------------------------
/**
 * 测试自定义不可重入锁
 */
@Slf4j(topic = "c.Test_AQS")
public class Test_AQS {

    static int i = 0;

    @Test
    public void test_MyAQS() {
        MyLock myLock = new MyLock();
        List<Thread> threadList = new ArrayList<>();
        for (int j = 0; j < 5; j++) {
            threadList.add(new Thread(() -> {
                myLock.lock();
                log.debug("获得锁...");
                try {
                    for (int k = 0; k < 10000; k++) {
                        i++;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    myLock.unlock();
                    log.debug("释放锁...");
                }
            }));
        }
        for (int j = 0; j < 5; j++) {
            threadList.add(new Thread(() -> {
                myLock.lock();
                log.debug("获得锁...");
                try {
                    for (int k = 0; k < 10000; k++) {
                        i--;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    myLock.unlock();
                    log.debug("释放锁...");

                }
            }));
        }
        threadList.forEach((s) -> {
            s.start();
        });
        threadList.forEach((s) -> {
            try {
                s.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        log.debug("i={}", i);
    }

}

-----------------输出----------------------------
11:48:44.333 [Thread-0] DEBUG c.Test_AQS - 获得锁...
11:48:44.339 [Thread-1] DEBUG c.Test_AQS - 获得锁...
11:48:44.340 [Thread-1] DEBUG c.Test_AQS - 释放锁...
11:48:44.339 [Thread-0] DEBUG c.Test_AQS - 释放锁...
11:48:44.340 [Thread-2] DEBUG c.Test_AQS - 获得锁...
11:48:44.341 [Thread-2] DEBUG c.Test_AQS - 释放锁...
11:48:44.341 [Thread-3] DEBUG c.Test_AQS - 获得锁...
11:48:44.341 [Thread-3] DEBUG c.Test_AQS - 释放锁...
11:48:44.341 [Thread-4] DEBUG c.Test_AQS - 获得锁...
11:48:44.342 [Thread-4] DEBUG c.Test_AQS - 释放锁...
11:48:44.342 [Thread-5] DEBUG c.Test_AQS - 获得锁...
11:48:44.343 [Thread-5] DEBUG c.Test_AQS - 释放锁...
11:48:44.343 [Thread-6] DEBUG c.Test_AQS - 获得锁...
11:48:44.343 [Thread-6] DEBUG c.Test_AQS - 释放锁...
11:48:44.344 [Thread-8] DEBUG c.Test_AQS - 获得锁...
11:48:44.345 [Thread-8] DEBUG c.Test_AQS - 释放锁...
11:48:44.345 [Thread-9] DEBUG c.Test_AQS - 获得锁...
11:48:44.345 [Thread-9] DEBUG c.Test_AQS - 释放锁...
11:48:44.345 [Thread-7] DEBUG c.Test_AQS - 获得锁...
11:48:44.346 [Thread-7] DEBUG c.Test_AQS - 释放锁...
11:48:44.346 [main] DEBUG c.Test_AQS - i=0

3.AQS要实现的目标

早期程序员会自己通过一种同步器去实现另一种相近的同步器，例如用可重入锁去实现信号量，或反之。这显然不
够优雅，于是在 JSR166（java 规范提案）中创建了 AQS，提供了这种通用的同步器机制。

AQS实现的功能目标:

阻塞版本获取锁 acquire 和非阻塞的版本尝试获取锁 tryAcquire

获取锁超时机制

通过打断取消机制

独占机制及共享机制

条件不满足时的等待机制

AQS要实现的性能目标:

Instead, the primary performance goal here is scalability: to predictably maintain efficiency even, or
especially, when synchronizers are contended.

4.AQS设计思想

获取锁的逻辑

while(state 状态不允许获取) {
    if(队列中还没有此线程) {
        入队并阻塞
    }
}
当前线程出队

释放锁的逻辑

if(state 状态允许了) {
	恢复阻塞的线程(s)
}

要点:

原子维护 state 状态
阻塞及恢复线程
维护队列

1) state 设计

state 使用 volatile 配合 cas 保证其修改时的原子性
state 使用了 32bit int 来维护同步状态，因为当时使用 long 在很多平台下测试的结果并不理想

2) 阻塞恢复设计

早期的控制线程暂停和恢复的 api 有 suspend 和 resume，但它们是不可用的，因为如果先调用的 resume
那么 suspend 将感知不到
解决方法是使用 park & unpark 来实现线程的暂停和恢复，具体原理在之前讲过了，先 unpark 再 park 也没
问题
park & unpark 是针对线程的，而不是针对同步器的，因此控制粒度更为精细
park 线程还可以通过 interrupt 打断

3) 队列设计

使用了 FIFO 先入先出队列，并不支持优先级队列
设计时借鉴了 CLH 队列，它是一种单向无锁队列

*初始状态:

*添加新节点后:

队列中有 head 和 tail 两个指针节点，都用 volatile 修饰配合 cas 使用，每个节点有 state 维护节点状态 .

入队伪代码，只需要考虑 tail 赋值的原子性 :

do {
    // 原来的 tail
    Node prev = tail;
    // 用 cas 在原来 tail 的基础上改为 node
} while(tail.compareAndSet(prev, node))

出队伪代码

// prev 是上一个节点
while((Node prev=node.prev).state != 唤醒状态) {
}
// 设置头节点
head = node;

CLH好处:

无锁,使用自旋
快速,无阻塞

AQS 在一些方面改进了 CLH :

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        // 队列中还没有元素 tail 为 null
        if (t == null) {
            // 将 head 从 null -> dummy
            if (compareAndSetHead(new Node()))
                tail = head;
            } else {
            // 将 node 的 prev 设置为原来的 tail
            node.prev = t;
            // 将 tail 从原来的 tail 设置为 node
            if (compareAndSetTail(t, node)) {
                // 原来 tail 的 next 设置为 node
                t.next = node;
                return t;
            }
        }
    }
}

5经常使用的AQS类

在这里插入图片描述

ReentrantLock
ReentrantreadWriteLock
Semaphore

脱氨垃圾

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
AQS(AbstractQueuedSynchronizer)同步器

AQS(AbstractQueuedSynchronizer)同步器文章目录AQS(AbstractQueuedSynchronizer)同步器1.概述2.自定义实现不可重入锁3.AQS要实现的目标4.AQS设计思想5经常使用的AQS类1.概述AQS全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步器工具的框架 .AQS的几种状态:/** waitStatus value to indicate thread has cancelled *///1:线程已经获得
复制链接

扫一扫

专栏目录