一、整体介绍

这章很重要，相对其他同步组件难，但是也很重要。

AQS的数据结构

在这里插入图片描述

AQS的设计

在这里插入图片描述

AQS实现的大致思路

AQS同步组件

在这里插入图片描述

二、各个组件具体的使用示例

*countdownlatch使用场景

在这里插入图片描述

countdownlatch使用场景

并行计算

countdownlatch使代码演示

package com.mmall.concurrency.AQS;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
public class countdownlatchDemo {
    private final static int threadCount = 200;

    public static void main(String[] args) throws Exception {

        ExecutorService exec = Executors.newCachedThreadPool();

        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    test(threadNum);
                } catch (Exception e) {
                    log.error("exception", e);
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        countDownLatch.await();
        log.info("finish");
        exec.shutdown();
    }

    private static void test(int threadNum) throws Exception {
        Thread.sleep(100);
        log.info("{}", threadNum);
        Thread.sleep(100);
    }
}

使用场景2，指定时间，超时不管，执行多少算多少，防止代码死卡

          // 只等待 test2 方法30 毫秒
        countDownLatch.await(30, TimeUnit.MILLISECONDS);

countDownLatch使用总结

final CountDownLatch countDownLatch = new CountDownLatch(Count);定义一个计数器
countDownLatch.countDown();
countDownLatch.await();
exec.shutdown();

二、Semaphore介绍

它用于仅能提供有限访问的资源，比如数据库连接输入最大20，做并发访问控制
代码如下，

import java.util.concurrent.*;

@Slf4j
public class SemaphoreDemo1 {
    private final static int threadCount = 50;

    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newCachedThreadPool();

        //  final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        //  定义一个信号量,每次允许并发20个
        final Semaphore semaphore = new Semaphore(20);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    semaphore.acquire();
                    test3(threadNum);
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception", e);
                }
            });
        }
        exec.shutdown();
    }
    private static void test3(int threadNum) throws Exception {
        Thread.sleep(100);
        log.info("{}", threadNum);
    }
}

但是有时候我们不一定一次拿到一个许可，而是多个。来看看多个的情况。

                    semaphore.acquire(5);
                    test3(threadNum);
                    semaphore.release(5);

但是还有一种情况，有时候并发实在太高了，我们想少点，多了之后就丢弃。重点看tryAcquire() 这个方法。代超时时间的参数。

                    if (semaphore.tryAcquire(1000,TimeUnit.MILLISECONDS)){
                        test3(threadNum);
                        semaphore.release();
                    }

总结

获取一个许可
获取多个许可
尝试获取一个许可
尝试等待获取一个许可
尝试等待获取多个许可

三、 CylicBarrier

在这里插入图片描述
countdownlatch 和 CylicBarrier相似：

前者计数器只能使用一次，而后者可以通过set重复使用
前者是一个或者多个线程要等其他线程都执行完后一起执行，一个或者多个线程要等待其他线程关系
而后者描述各个进程相互等待的关系。更强大

package com.mmall.concurrency.AQS;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
public class CycliBarrierDemo {
    private static int threadNum;
    // 等待的线程数够5个就执行
    static CyclicBarrier cyclicBarrier = new CyclicBarrier(5);
    public static void main(String[] args) throws Exception {
        //线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i< 10; i++){
            final int threadNum = i;
            Thread.sleep(1000); //执行前睡一会
            executorService.execute( () -> {
                try{
                    race(threadNum);
                }catch (Exception e){
                    log.error("race error :",e);
                }
            });
        }
    }

    public static void race(int threadNum) throws Exception{
        Thread.sleep(1000);
        log.info("{} is ready.", threadNum);
        cyclicBarrier.await();
        log.info("{} is continue.", threadNum);
    }
}

awite()还有等待时

cyclicBarrier.await(1000, TimeUnit.MILLISECONDS); 会报错

报错时，如果还想执行下面的语句，那就try{} catch（）{}

19:06:29.114 [pool-1-thread-1] INFO com.mmall.concurrency.AQS.CycliBarrierDemo - 0 is ready.
19:06:30.112 [pool-1-thread-2] INFO com.mmall.concurrency.AQS.CycliBarrierDemo - 1 is ready.
19:06:30.189 [pool-1-thread-1] ERROR com.mmall.concurrency.AQS.CycliBarrierDemo - race error :
java.util.concurrent.TimeoutException: null
	at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:257)
	at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
	at com.mmall.concurrency.AQS.CycliBarrierDemo.race(CycliBarrierDemo.java:38)

//  改造之后
19:09:57.986 [pool-1-thread-1] INFO com.mmall.concurrency.AQS.CycliBarrierDemo - 0 is ready.
19:09:58.981 [pool-1-thread-2] INFO com.mmall.concurrency.AQS.CycliBarrierDemo - 1 is ready.
19:09:58.998 [pool-1-thread-1] WARN com.mmall.concurrency.AQS.CycliBarrierDemo - ===============出错？别出来
19:09:58.998 [pool-1-thread-2] WARN com.mmall.concurrency.AQS.CycliBarrierDemo - ===============出错？别出来
19:09:58.998 [pool-1-thread-1] INFO com.mmall.concurrency.AQS.CycliBarrierDemo - 0 is continue.
19:09:58.998 [pool-1-thread-2] INFO com.mmall.concurrency.AQS.CycliBarrierDemo - 1 is continue.

static CyclicBarrier cyclicBarrier = new CyclicBarrier(5);这个函数里还可以有优先执行的回调函数。

    // 等待的线程数够5个就执行
    static CyclicBarrier cyclicBarrier = new CyclicBarrier(5,
            () ->{log.info("====running"); });

运行结果：

19:13:26.624 [pool-1-thread-5] INFO com.mmall.concurrency.AQS.CycliBarrierDemo - 4 is ready.
19:13:26.624 [pool-1-thread-5] INFO com.mmall.concurrency.AQS.CycliBarrierDemo - ====running
19:13:26.624 [pool-1-thread-5] INFO com.mmall.concurrency.AQS.CycliBarrierDemo - 4 is continue.
19:13:26.625 [pool-1-thread-1] INFO com.mmall.concurrency.AQS.CycliBarrierDemo - 0 is continue.

四、ReentrantLock（可重入锁）和synchronized区别

reentrantlock 阻止锁在用户级别处理，而不进入内核阻塞，用CAS原理
在这里插入图片描述

代码演示功能

    // 定义锁
    private static Lock lock = new ReentrantLock();
==============================
    private static void add(){
        lock.lock();
        try{
            count++;
        }catch (Exception e){
            log.error("{} add 报错", e.getMessage());
        }finally {
            lock.unlock();
        }
    }

再深入看reentrantlock源码做了什么？

在这里插入图片描述

接下来再看看juc的另外一个锁ReentrantReadWriteLock

ReentrantReadWriteLock：在没有任何读写锁的时候才可以取得写入锁，读取锁定。

package com.mmall.concurrency.lock;

import lombok.extern.slf4j.Slf4j;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

@Slf4j
public class ReadWriteLock {
    private final Map<String, Data> map = new TreeMap<>();
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock readLock = lock.readLock();
    private final Lock writeLock = lock.writeLock();

    //  获取方法
    public Data get(String key){
        readLock.lock();
        try{
            return map.get(key);
        }finally {
            readLock.unlock();
        }
    }

    // 获取一大堆方法
    public Set<String> getAllKeys(){
        readLock.lock();
        try{
            return map.keySet();
        }finally {
            readLock.unlock();
        }
    }

    // put func
    public Data put(String key, Data value){
        writeLock.lock();
        try{
            return map.put(key,value);
        }finally {
            readLock.unlock();
        }
    }

    // Data 方法
    class Data{

    }
}

再来介绍一种锁StampedLock

主要分析悲观乐观的区别

package com.mmall.concurrency.lock;

import java.util.concurrent.locks.StampedLock;

public class StampLockDemo {

    class Point {
        private double x, y;
        private final StampedLock sl = new StampedLock();

        void move(double deltaX, double deltaY) { // an exclusively locked method
            long stamp = sl.writeLock();
            try {
                x += deltaX;
                y += deltaY;
            } finally {
                sl.unlockWrite(stamp);
            }
        }

        //下面看看乐观读锁案例
        double distanceFromOrigin() { // A read-only method
            long stamp = sl.tryOptimisticRead(); //获得一个乐观读锁
            double currentX = x, currentY = y;  //将两个字段读入本地局部变量
            if (!sl.validate(stamp)) { //检查发出乐观读锁后同时是否有其他写锁发生？
                stamp = sl.readLock();  //如果没有，我们再次获得一个读悲观锁
                try {
                    currentX = x; // 将两个字段读入本地局部变量
                    currentY = y; // 将两个字段读入本地局部变量
                } finally {
                    sl.unlockRead(stamp);
                }
            }
            return Math.sqrt(currentX * currentX + currentY * currentY);
        }

        //下面是悲观读锁案例
        void moveIfAtOrigin(double newX, double newY) { // upgrade
            // Could instead start with optimistic, not read mode
            long stamp = sl.readLock();
            try {
                while (x == 0.0 && y == 0.0) { //循环，检查当前状态是否符合
                    long ws = sl.tryConvertToWriteLock(stamp); //将读锁转为写锁
                    if (ws != 0L) { //这是确认转为写锁是否成功
                        stamp = ws; //如果成功 替换票据
                        x = newX; //进行状态改变
                        y = newY;  //进行状态改变
                        break;
                    } else { //如果不能成功转换为写锁
                        sl.unlockRead(stamp);  //我们显式释放读锁
                        stamp = sl.writeLock();  //显式直接进行写锁 然后再通过循环再试
                    }
                }
            } finally {
                sl.unlock(stamp); //释放读锁或写锁
            }
        }
    }
}

stampedLock 的用法

  // 定义锁
    private static StampedLock stampedLock = new StampedLock();
    =========
    private static void add1(){
        long stamp = stampedLock.writeLock();
        try{
            count++;
        }catch (Exception e){
            log.error("{} add 报错", e.getMessage());
        }finally {
            stampedLock.unlock(stamp);
        }
    }

总结各种锁

synchronized实在jvm层面实现，jvm自动解锁，其他一定要自己解锁。
reentrantlock , reentrantreadlock, reentrantwritelock, stampedlock,都是在对象层面锁定，unlock放在finally更安全。
stampedlock，改进很大，尤其在读很大的时候，容易吴用

关于condition的使用

多线程间协调通信工具类，条件具备，等待进程唤醒。
很少用，面试知道即可

package com.mmall.concurrency.lock;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
@Slf4j
public class ConditionLock {

    public static void main(String[] args) {
        ReentrantLock reentrantLock = new ReentrantLock();
        Condition condition = reentrantLock.newCondition();

        new Thread(() -> {
            try {
                reentrantLock.lock();
                log.info("wait signal"); // 1
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.info("get signal"); // 4
            reentrantLock.unlock();
        }).start();

        new Thread(() -> {
            reentrantLock.lock();
            log.info("get lock"); // 2
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            condition.signalAll();
            log.info("send signal ~ "); // 3
            reentrantLock.unlock();
        }).start();
    }
}

【高并发9】AQS-AbstractQueuedSynchronizer的详解及其同步组件的使用

一、整体介绍

AQS的数据结构

AQS的设计

AQS实现的大致思路

AQS同步组件

二、各个组件具体的使用示例

*countdownlatch使用场景

countdownlatch使用场景

countdownlatch使代码演示

使用场景2，指定时间，超时不管，执行多少算多少，防止代码死卡

countDownLatch使用总结

二、Semaphore介绍

总结

三、 CylicBarrier

awite()还有等待时

报错时，如果还想执行下面的语句，那就try{} catch（）{}

static CyclicBarrier cyclicBarrier = new CyclicBarrier(5);这个函数里还可以有优先执行的回调函数。

四、ReentrantLock（可重入锁）和synchronized区别

代码演示功能

再深入看reentrantlock源码做了什么？

接下来再看看juc的另外一个锁ReentrantReadWriteLock

再来介绍一种锁StampedLock

stampedLock 的用法

总结各种锁

关于condition的使用

猜你喜欢

【 高并发9】AQS-AbstractQueuedSynchronizer的详解及其同步组件的使用

一、整体介绍

AQS的数据结构

AQS的设计

AQS实现的大致思路

AQS同步组件

二、各个组件具体的使用示例

*countdownlatch使用场景

countdownlatch使用场景

countdownlatch使代码演示

使用场景2，指定时间，超时不管，执行多少算多少，防止代码死卡

countDownLatch使用总结

二、Semaphore介绍

总结

三、 CylicBarrier

awite()还有等待时

报错时，如果还想执行下面的语句，那就try{} catch（）{}

static CyclicBarrier cyclicBarrier = new CyclicBarrier(5);这个函数里还可以有优先执行的回调函数。

四、ReentrantLock（可重入锁）和synchronized区别

代码演示功能

再深入看reentrantlock源码做了什么？

接下来再看看juc的另外一个锁ReentrantReadWriteLock

再来介绍一种锁StampedLock

stampedLock 的用法

总结各种锁

关于condition的使用

猜你喜欢

【高并发9】AQS-AbstractQueuedSynchronizer的详解及其同步组件的使用