看得懂的AQS理解

最新推荐文章于 2024-08-18 23:25:39 发布

石以砥焉，以锐为利

最新推荐文章于 2024-08-18 23:25:39 发布

阅读量771

点赞数 17

分类专栏：并发学习文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_63803244/article/details/140548751

版权

并发学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

AQS

同步框架，内部维护一个FIFO的双向队列，CLH同步队列。AQS依赖volitail修饰的state标记是否持有锁。乐观锁。维护了一个Node，包含是共享的还是独占的，

在这里插入图片描述

state变量，volatile。state等于0或者1代表被加锁或者没被加锁。那个线程把这个公共变量占住，就是持有了锁。

请求的共享资源空闲：就将请求资源的线程设成工作线程，将共享资源锁定。
如果请求的资源被占用，需要线程阻塞等待以及唤醒机制，借助的是CLH队列实现的，将暂时获取不到资源的线程放到队列里。CLH队列是一个虚拟的双向队列，没有new的动作。是一个一个节点链接形成的。

比喻:求而不得，变成望夫石，盯着资源。已经变成石头了，需要唤醒它。

在这里插入图片描述

头线程用完了，将head指针后移。

对于线程的占用方式：

（1）独占：ReenttrantLock，只有一个线程能拿到锁，和syc（不公平的锁）一样。ReenttrantLock有公平锁和不公平锁两种。

公平锁：按照线程在队列中的顺序，先到者先拿到锁。

非公平锁：当线程获取锁时，先通过两次CAS去抢锁，没抢到加到队列中等待唤醒。

比喻：排队买票，非公平锁能不能抢到取决于现在正在交易嘛，如果正在交易就抢不到。如果是交易间隙能抢到。

公平锁lock（）实现

tryacquire()方法：获取当前线程，获取state状态。

----如果state是0，检查当前线程是不是队列中的首线程（排队动作）。如果是队列中的头结点，就CAS替换state，设置持有锁的线程为当前线程。

----如果state不是0，判断当前线程是持有锁的线程吗。再次加锁，state+=1；

非公平锁lock（）实现（吞吐量大，性能好）

上来先cas抢一次锁，抢不到调用acquire()方法。acquire()方法调用tryacquire方法。tryacquire调用nofairtryacquire。先获取当前线程和状态。

如果state是0，将开始抢。抢到就是自己的。如果没抢到就看看当前占用资源的线程是不是本线程，如果是就state+=1。如果不是就没抢到放队列。

默认是非公平锁。

区别：非公平锁在调用 lock 后，首先就会调用 CAS 进行一次抢锁，如果这个时候恰巧锁没有被占用，那么直接就获取到锁返回了。

非公平锁在 CAS 失败后，和公平锁一样都会进入到 tryAcquire 方法，在 tryAcquire 方法中，如果发现锁这个时候被释放了（state == 0），非公平锁会直接 CAS 抢锁，但是公平锁会判断等待队列是否有线程处于等待状态，如果有则不去抢锁，乖乖排到后面。

（2）共享

Semaphore:控制线程执行的许可，控制线程执行的数量。可以控制流量，消峰。

package com.qxh.bf.aqs;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class SemaphoreExample1 {
    // 请求的数量
    private static final int threadCount = 550;

    public static void main(String[] args) throws InterruptedException {
        // 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）
        ExecutorService threadPool = Executors.newFixedThreadPool(300);
        // 一次只能允许执行的线程数量。
        final Semaphore semaphore = new Semaphore(20);

        for (int i = 0; i < threadCount; i++) {
            final int threadnum = i;
            threadPool.execute(() -> {// Lambda 表达式的运用
                try {
                    semaphore.acquire();// 获取一个许可，所以可运行线程数量为20/1=20
                    test(threadnum);
                    semaphore.release();// 释放一个许可
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            });
        }
        threadPool.shutdown();
        System.out.println("finish");
    }

    public static void test(int threadnum) throws InterruptedException {
        Thread.sleep(1000);// 模拟请求的耗时操作
        System.out.println("threadnum:" + threadnum);
        Thread.sleep(1000);// 模拟请求的耗时操作
    }
}

CountDownLatch：允许count个线程阻塞到一个位置，直到所有线程的任务执行完。每使用一次就以CAS的方式对count－1.调用await的方法，如果state不为0就代表没完成，一直阻塞。当state为0，释放阻塞的线程。

场景：某个线程等待前n个线程执行完毕。

实现多个线程的开始执行任务的最大并行性，多个线程同时被唤醒，类似赛跑。

package com.qxh.bf.aqs;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CountDownLatchExample1 {
    // 请求的数量
    private static final int threadCount = 550;

    public static void main(String[] args) throws InterruptedException {
        // 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）
        ExecutorService threadPool = Executors.newFixedThreadPool(300);
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            final int threadnum = i;
            threadPool.execute(() -> {// Lambda 表达式的运用
                try {
                    test(threadnum);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } finally {
                    countDownLatch.countDown();// 表示一个请求已经被完成
                }

            });
        }
        countDownLatch.await();
        threadPool.shutdown();
        System.out.println("finish");
    }

    public static void test(int threadnum) throws InterruptedException {
        Thread.sleep(1000);// 模拟请求的耗时操作
        System.out.println("threadnum:" + threadnum);
        Thread.sleep(1000);// 模拟请求的耗时操作
    }
}
//这个代码中一定要注意countdown的次数要大于等于创建线程的个数，否则主线程就会一直等待。

CyclicBarrier循环栅栏(流量控制 )

全部线程到达被阻塞点，才能继续前进。类似：电影中，金木水火土集齐才能通过关卡。

package com.qxh.bf.aqs;
import java.util.concurrent.*;
public class CyclicBarrierExample2 {
    // 请求的数量
    private static final int threadCount = 550;
    // 需要同步的线程数量
    private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5);

    public static void main(String[] args) throws InterruptedException {
        // 创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);

        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            Thread.sleep(1000);
            threadPool.execute(() -> {
                try {
                    test(threadNum);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            });
        }
        threadPool.shutdown();
    }

    public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {
        System.out.println("threadnum:" + threadnum + "is ready");
        try {
            /**等待60秒，保证子线程完全执行结束*/
            cyclicBarrier.await(60, TimeUnit.SECONDS);
        } catch (Exception e) {
            System.out.println("-----CyclicBarrierException------");
        }
        System.out.println("threadnum:" + threadnum + "is finish");
    }

}