AQS原理

AQS的全程为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包

AQS的核心思想：如果被请求的共享资源空闲，那么当前请求的线程设置为有效的工作线程，并将共享资源设置为锁定状态，如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。
CLH队列是一个虚拟的双向队列，虚拟的双向队列即不存在队列实例，仅存在节点之间的关联关系。
AQS是将每一条请求共享资源的线程封装成一个CLH锁队列的一个结点（Node），来实现锁的分配。
简单来说，AQS就是基于CLH队列，用volatile修饰共享变量state，线程通过CAS去改变状态符，成功则获取锁成功，失败则进入等待队列，等待被唤醒。

AQS是自旋锁，在等待唤醒的时候，经常会使用自旋的方式，不停地尝试获取锁，直到被其他线程获取成功。

image.png

实现了AQS的锁有：自旋锁，读写锁，信号量，条件产量，互斥锁，栅栏等。
AQS维护了一个volatile int state 和一个FIFO线程等待队列，多线程争用资源被阻塞的时候就会进入这个队列。state就是共享资源，其访问方式有如下三种：
getState(),setState(),compareandsetState();
AQS定义了两种资源共享方式：
1.独占：只有一个线程能执行，reentrantlock
2.共享：多个线程可以同时执行，Semaphore，CountDownLatch，ReadWriteLock，CyclicBarrier。

AQS底层使用了模板方法模式

同步器的设计是基于模板方法模式，如果需要自定义同步器一般的方式是这样的：
1.使用者继承AbstractQueuedSynchronizer并重写指定的方法。
2.将AQS组合在自定义同步组件的实现中，调用其模板方法，而这些模板方法会调用使用者重写的方法。这和我们以往通过实现接口的方式有很大的区别。

自定义同步器在实现的时候只需要实现共享资源state的获取和释放方式即可，至于具体线程等待队列的维护，AQS已经在顶层实现好了。自定义同步器实现的时候主要实现下面几种方法：
1.isHeldExclusively（）：该线程是否正在独占资源，只有用到condition采取实现它。
2.tryAcquire（int）:独占方式。尝试获取资源，成功则返回true，失败则返回false。
3.tryRelease（int）：独占方式。尝试释放资源，成功则返回true，失败则返回false。
4.tryAcquireShared（int）：共享方式，尝试获取资源。负数表示失败，0表示成功，但是没有剩余可利用资源；正数表示成功，有剩余资源。
5.tryReleaseShared（int）：共享方式，尝试释放资源，如果释放后允许唤醒后续等待节点返回true，否则返回false。

reentranlock为例：state初始化为0，表示未锁定状态，A线程lock（）时，会调用tryAcquire（）独占锁并将state+1之后其他线程在想tryAcquire（）的时候就会失败，直到A线程unlock（）到state=0为止，其他线程才会有机会获取该锁，A释放锁之前，state可以叠加，这就是可重入锁的概念。
注意：获取多少次锁就要释放多少次锁，保证state是能回到零态的。

以countdownlatch为例，任务分为N个子线程去执行，state就初始化为N，N个线程并行执行，每个线程执行完成之后coutDown（）一次，state就会CAS减一，当N子线程全部执行完毕，state=0，会unpark（）主调用线程，主调用线程就会从await（）函数返回，继续之后的动作。

一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如ReentrantReadWriteLock。
在acquire（），acquireShared（）两种方式下，线程在等待队列中都是忽略中断的，acquireInterruptibly（）/acquire SharedInterruptibly()是支持响应中断的。

Condition的demo代码

public class Thread_await_signal{
    public static void main(String[] args){
        ExecutorService executorService = Executors.newCachedThreadPool();
        AwaitSignalExam exam = new AwaitSignalExam();
        executorService.execute(()->exam.after());
        executotService.execute(()->exam.before());
    }
}
//java.util.concurrent类库中提供了condition类来实现线程之间的协调，
//可以在Condition上调用await()方法使线程挂起。
//其他线程可以调用signal()或signalAll()来唤醒等待的线程。
//使用Lock来获取一个condition对象。

class AwaitSignalExample{
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void beforE(){
        lock.lock();
        try{
            System.out.println("before func");
            condition.signalAll();
            //唤醒挂起的其他线程
        }finally{
            lock.unlock();
        }
    }

    public void afterE(){
        lock.lock();
        try{
            condition.await();
            System.out.println("after func");
        }catch(Exception ex){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
}

wait() 与 await()区别

  1. wait()是Object超类中的方法，而await()是ConditionObject类里面的方法.
  2. await会导致当前线程被阻塞，会释放锁，这点和wait是一样的
  3. await中的lock不再使用synchronized把代码同步包装起来
  4. await的阻塞需要另外的一个对象condition
  5. notify是用来唤醒使用wait的线程；而signal是用来唤醒await线程。
  6. 所在的超类不同使用场景也不同，wait一般用于Synchronized中，而await只能用于ReentrantLock锁中

CountDownLatch

线程池接受方法，execute（）可以接受一个实现了Runnable接口的对象，也可以通过lambda接口传递相应的对象方法。

  • 下面这个CountDL是个普通的class类（executorService是线程池方法）
    CountDL countDL = new CountDL(2);
    executorService.execute(()->countDL.count());

  • 下面这个类是实现了Runnable接口的方法。
    CountDL countDL = new CountDL(2);
    executorService.execute(countDL);

使用到的函数有：
private CountDownLatch count = new CountDownLatch();
count.countdown();
count.await();  等待count数字为0，才执行后续的代码

public class kuaisupaixu {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        CountDL countDL = new CountDL(2);
        executorService.execute(()->countDL.count());
        executorService.execute(()->countDL.count());
        countDL.count.await();
        System.out.println("最终实现");
    }
    static class CountDL{
        private int cap;
        private CountDownLatch count ;
        public CountDL(int cap) {
            this.cap = cap;
            count = new CountDownLatch(cap);
        }
        public void count() {
            count.countDown();
            System.out.println(count.getCount());
        }

    }
}

public class kuaisupaixu {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        CountDL countDL = new CountDL(2);
        executorService.execute(countDL);
        executorService.execute(countDL);
        countDL.count.await();
        System.out.println("最终实现");
    }
    static class CountDL implements Runnable{
        private int cap;
        private CountDownLatch count ;
        public CountDL(int cap) {
            this.cap = cap;
            count = new CountDownLatch(cap);
        }

        @Override
        public void run() {
            Random random = new Random();
            try {
                TimeUnit.SECONDS.sleep(random.nextInt(4)+4);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(count.getCount());
            count.countDown();
        }
    }
}

CyclicBarrier

作用：所有线程运行到cyclicBarrier.await（）才会进行下一步操作。

使用cyclicBarrier的两个重要方法

1.构造方法：
public CyclicBarrier(int parties)
public CyclicBarrier(int parties,Runnable barrierAction);

解析：

  • parties 是参与线程的个数
  • 第二个构造方法有一个 Runnable 参数，这个参数的意思是最后一个到达线程要做的任务
重要方法
public int await();
public int await(long timeout,TimeUnit unit);

解析：

  • 线程调用await()表示自己已经到达栅栏。
  • BrokenBarrierException() 表示栅栏已经被破坏，破坏的原因可能是其中一个线程await()时被中断或者超时。
public class kuaisupaixu {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        CyclicBarrier cb = new CyclicBarrier(3, () -> {
            System.out.println(Thread.currentThread().getName() + "完成最后的任务");
        });
        CyclicBarrierTest cyclicBarrier = new CyclicBarrierTest(cb);
        executorService.execute(cyclicBarrier);
        executorService.execute(cyclicBarrier);
        executorService.execute(cyclicBarrier);

        System.out.println("最终实现");
    }
    static class CyclicBarrierTest implements Runnable{
        private CyclicBarrier cyclicBarrier ;
        public CyclicBarrierTest(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + " 到达栅栏 A");
                cyclicBarrier.await();
                System.out.println(Thread.currentThread().getName() + " 离开栅栏 A");

                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + " 到达栅栏 B");
                cyclicBarrier.await();
                System.out.println(Thread.currentThread().getName() + " 离开栅栏 B");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } catch (BrokenBarrierException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

CyclicBarrier 使用场景

可以用于多线程计算数据，最后合并计算结果的场景。

CyclicBarrier 与 CountDownLatch 区别

  • CountDownLatch 是一次性的，CyclicBarrier 是可循环利用的
  • CountDownLatch 参与的线程的职责是不一样的，有的在倒计时，有的在等待倒计时结束。CyclicBarrier 参与的线程职责是一样的。

semaphore

信号量主要用于两个目的：

  • 一个是用于共享资源的互斥使用
  • 用于并发线程数的控制(Semaphore可以用来做流量分流，特别是对公共资源有限的场景，比如数据库连接。比如只有10个数据库连接，但是有几十个线程需要对上万个文件进行存储，那么就可以使用semaphore进行线程数量控制)。
/**
* 初始化一个信号量为3，默认是false 非公平锁， 模拟3个停车位
*/
Semaphore semaphore = new Semaphore(3, false);

原理：

Semaphore内部维护了一组虚拟的许可，许可的数量可以通过构造函数的参数指定。

  • 访问特定资源前，必须使用acquire方法获得许可，如果许可数量为0，该线程则一直阻塞，直到有可用许可。
  • 访问资源后，使用release释放许可。
    Semaphore和ReentrantLock类似，获取许可有公平策略和非公平许可策略，默认情况下使用非公平策略。
public class kuaisupaixu {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        Semaphore semaphore = new Semaphore(3);
        SemaphoreTest semaphoreTest = new SemaphoreTest(semaphore);
        executorService.execute(semaphoreTest);
        executorService.execute(semaphoreTest);
        executorService.execute(semaphoreTest);
        System.out.println("最终实现");
    }
    static class SemaphoreTest implements Runnable{
        private Semaphore semaphore ;
        private AtomicInteger integer =new AtomicInteger();
        public SemaphoreTest(Semaphore semaphore) {
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName()+
                        ":#"+integer.incrementAndGet()+"-我抢到了");
                semaphore.release();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 213,047评论 6赞 492
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,807评论 3赞 386
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 158,501评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,839评论 1赞 285
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,951评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,117评论 1赞 291
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,188评论 3赞 412
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,929评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,372评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,679评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,837评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,536评论 4赞 335
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,168评论 3赞 317
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,886评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,129评论 1赞 267
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,665评论 2赞 362
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,739评论 2赞 351

推荐阅读更多精彩内容