• JUC P6 AQS，读写锁，StampLock，Semaphore，CountdownLatch，CyclicBarrier 基础+代码

    JUC P6 AQS，读写锁，StampLock，Semaphore，CountdownLatch，CyclicBarrier 基础+代码

    教程：https://www.bilibili.com/video/BV16J411h7Rd

    12. AQS

    12.1 概述

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

    特点：

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

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

    • tryAcquire：尝试获取锁，底层使用 park/unpark 实现
    • tryRelease：尝试释放锁
    • tryAcquireShared
    • tryReleaseShared
    • isHeldExclusively

    12.2 自定义不可重入锁

    @Slf4j(topic = "c.InitTest")
public class InitTest {
    public static void main(String[] args) {
        MyLock lock = new MyLock();
        new Thread(() -> {
            lock.lock();
            try {
                log.debug("1");
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "t1").start();

        new Thread(() -> {
            lock.lock();
            try {
                log.debug("2");
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }
}

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

    // 独占锁, 同步器类
    static class MySync extends AbstractQueuedSynchronizer {
        @Override
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0, 1)) {
                // 加锁, 设置 owner 为当前线程
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        @Override
        protected boolean tryRelease(int arg) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

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

        /**
         * 新建一个条件变量
         */
        public Condition newCondition() {
            return new ConditionObject();
        }
    }

    private final MySync sync = new MySync();

    /**
     * 加锁(不成功会进入等待队列)
     */
    @Override
    public void lock() {
        sync.acquire(1); // 不能用 tryAcquire(只能尝试一次)
    }

    /**
     * 加锁, 可打断
     */
    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    /**
     * 尝试加锁, 只尝试一次
     */
    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    /**
     * 带超时时间的尝试加锁
     */
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(time));
    }

    /**
     * 解锁
     */
    @Override
    public void unlock() {
        sync.release(1); // release 会唤醒阻塞的线程, tryRelease 不会
    }

    /**
     * 提供一个条件变量
     */
    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115

    在这里插入图片描述

    12.3 ReentrantLock 原理

    在这里插入图片描述

    12.3.1 可重入原理

    获取锁：
    在这里插入图片描述

    释放锁：

    1. state--
    2. 若 state == 0，当前线程设为 null，当前线程释放锁成功
    3. 若 state != 0，表示当前线程还没执行结束，释放锁失败
    12.3.2 可打断原理
    12.3.3 不公平锁原理
    • 当一个线程释放锁时，将 state 设置为 0，并且通知队列中的线程
    • 此时突然有一个新的线程进行了 CAS 操作，将 state 设置为 1
    • 那么在队列中被通知的线程又进行了 CAS，发现 state 已经是 1 了，因此获取锁失败，继续等待
    12.3.4 公平锁原理
    • 当一个线程释放锁时，将 state 设置为 0，并通知队列中的线程
    • 此时突然有一个新的线程来，他会查看自己是否在队列中，若不在就会先排队
    12.3.5 条件变量实现原理

    12.4 读写锁

    12.4.1 ReentrantReadWriteLock

    当读操作远远高于写操作时，这时候可以使用读写锁让读-读可以并发执行，提高性能。

    类似数据库终得共享锁。

    使用方法
    @Slf4j(topic = "c.InitTest")
public class InitTest {
    public static void main(String[] args) {
        DataContainer container = new DataContainer();
        new Thread(container::read,"t1").start();
        new Thread(container::write,"t2").start();
    }
}

@Slf4j(topic = "c.DataContainer")
class DataContainer {
    private Object data;
    private final ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock r = rw.readLock();
    private final ReentrantReadWriteLock.WriteLock w = rw.writeLock();

    @SneakyThrows
    public Object read() {
        r.lock();
        log.debug("获取读锁");
        try {
            log.debug("read...");
            TimeUnit.SECONDS.sleep(2);
            return data;
        } finally {
            log.debug("释放读锁");
            r.unlock();
        }
    }

    @SneakyThrows
    public void write() {
        w.lock();
        log.debug("获取写锁");
        try {
            log.debug("write...");
            TimeUnit.SECONDS.sleep(2);
        } finally {
            log.debug("释放写锁");
            w.unlock();
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    在这里插入图片描述
    读写互斥，写写互斥，读读可并发。

    注意事项
    • 读锁不支持条件变量
    • 重入时升级不支持：即持有读锁得情况下去获取写锁，会导致获取读写锁永久等待
    r.lock();
try {
    w.lock();
    try {
        log.debug("upgrade...");
    } finally {
        w.unlock();
    }
} finally {
    r.unlock();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 锁从写锁降级到读锁是可以得
    w.lock();
try {
    r.lock();
    try {
        log.debug("read...");
    } finally {
        r.unlock();
    }
    log.debug("write...");
} finally {
    w.unlock();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    在这里插入图片描述

    12.4.2 StampedLock

    JDK 8 引入，进一步优化读性能，特点是在使用读锁，写锁时都必须配合戳使用。

    支持乐观读，tryOptimisticRead()，读取完毕后需要做一次戳校验，若校验通过，表示期间没有写操作，数据可以安全使用，若校验没有通过，需要重新获取读锁，保证数据安全。

    乐观读是不加锁的。

    使用方法
    @Slf4j(topic = "c.InitTest")
public class InitTest {
    public static void main(String[] args) {
        DataContainer container = new DataContainer(5);
        new Thread(container::read,"t1").start();
        new Thread(() -> container.write(100),"t2").start();
    }
}

@Slf4j(topic = "c.DataContainer")
class DataContainer {
    private int data;
    private final StampedLock lock = new StampedLock();

    public DataContainer(int data) {
        this.data = data;
    }

    @SneakyThrows
    public int read() {
        long stamp = lock.tryOptimisticRead();
        log.debug("乐观读锁...{}", stamp);
        TimeUnit.SECONDS.sleep(1);
        if (lock.validate(stamp)) {
            log.debug("乐观读结束...{}", stamp);
            return data;
        }

        log.debug("升级读锁...{}", stamp);
        try {
            stamp = lock.readLock();
            log.debug("读锁 {}", stamp);
            TimeUnit.SECONDS.sleep(1);
            return data;
        } finally {
            log.debug("释放读锁 {}", stamp);
            lock.unlockRead(stamp);
        }
    }

    @SneakyThrows
    public void write(int newData) {
        long stamp = lock.writeLock();
        log.debug("写锁 {}", stamp);
        try {
            TimeUnit.SECONDS.sleep(2);
            this.data = newData;
        } finally {
            log.debug("释放写锁 {}", stamp);
            lock.unlockWrite(stamp);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53

    在这里插入图片描述

    注意事项
    • 不支持条件变量
    • 不支持可重入

    12.5 信号量 Semaphore

    信号量，用来限制能同时访问共享资源的线程的上限。

    12.5.1 使用方法
    @Slf4j(topic = "c.InitTest")
public class InitTest {
    public static void main(String[] args) {
        // 1. 创建 Semaphore 对象
        Semaphore semaphore = new Semaphore(3);

        // 2. 10 个线程同时运行
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    log.debug("running...");
                    TimeUnit.SECONDS.sleep(1);
                    log.debug("end...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }

            }).start();
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    在这里插入图片描述

    12.5.2 Semaphore 应用
    • 限流，在访问高峰期时，让请求线程阻塞，高峰期过去再释放许可，当然它只适合限制单机线程数量，并且仅是限制线程数，而不是限制资源数（例如连接池，可以对比 Tomcat LimitLatch 的实现）
    • 实现简单连接池，对比享元模式下的实现（用 wait / notify），性能和可读性显然更好，注意下面的实现中线程数和数据库连接数是相等的。
    12.5.3 改进数据库连接池
    @Slf4j(topic = "c.InitTest")
public class InitTest {
    public static void main(String[] args) {
        Pool pool = new Pool(2);
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                Connection conn = pool.borrow();
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    pool.free(conn);
                }
            }).start();
        }
    }

}

@Slf4j(topic = "c.Pool")
class Pool {
    // 1. 池大小, 也可以设置为可变
    private final int poolSize;

    // 2. 连接数组对象
    private Connection[] connections;

    // 3. 连接状态数组 0 表示空闲, 1 表示繁忙
    private AtomicIntegerArray states;

    // 新增 semaphore 变量
    private Semaphore semaphore;

    // 4. 构造方法
    public Pool(int poolSize) {
        this.poolSize = poolSize;
        this.connections = new Connection[poolSize];
        this.states = new AtomicIntegerArray(poolSize);
        for (int i = 0; i < poolSize; i++) {
            connections[i] = new MockConnection("连接对象-" + i);
        }
        this.semaphore = new Semaphore(poolSize);
    }

    // 5. 借连接
    @SneakyThrows
    public Connection borrow() {
        // 获取许可, 没有许可的线程, 再此等待
        semaphore.acquire();
        for (int i = 0; i < poolSize; i++) {
            // 获取空闲连接
            if (states.get(i) == 0 && states.compareAndSet(i, 0, 1)) {
                log.debug("Borrow {}", connections[i]);
                return connections[i];
            }
        }
        return null; // 实际不会执行
    }

    // 6. 归还连接
    public void free(Connection connection) {
        for (int i = 0; i < poolSize; i++) {
            if (connections[i] == connection) {
                states.set(i, 0);
                log.debug("Free: {}", connection);
                semaphore.release(); // 释放
                break;
            }
        }
    }
}

class MockConnection implements Connection {

    private String name;

    public MockConnection(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "MockConnection{" +
                "name='" + name + '\'' +
                '}';
    }
    /**
	 * 省略实现方法。。。。
	*/
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91

    12.6 倒计时锁 CountdownLatch

    • 用来进行线程同步协作，等待所有线程完成倒计时
    • 其中构造参数用来初始化等待计数值，await() 用来等待计数归零，countDown() 用来让计数减一
    12.6.1 使用方法
    @Slf4j(topic = "c.InitTest")
public class InitTest {
    @SneakyThrows
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(3);

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                log.debug("begin...");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                latch.countDown();
                log.debug("end...");
            }).start();
        }

        log.debug("waiting...");
        latch.await();
        log.debug("wake up...");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    在这里插入图片描述

    12.6.2 结合线程池
    @Slf4j(topic = "c.InitTest")
public class InitTest {
    @SneakyThrows
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(4);
        CountDownLatch latch = new CountDownLatch(3);

        for (int i = 0; i < 3; i++) {
            pool.submit(() -> {
                log.debug("begin...");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                latch.countDown();
                log.debug("end... {}", latch.getCount());
            });
        }

        pool.submit(() -> {
            log.debug("waiting...");
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("wake up...");
        });
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    12.6.3 应用（主线程等待所有玩家加载完成）
    @Slf4j(topic = "c.InitTest")
public class InitTest {
    @SneakyThrows
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        // 保存所有玩家的加载进度
        String[] all = new String[10];
        // 用于设置随机随眠时间
        Random random = new Random();
        // 计数
        CountDownLatch latch = new CountDownLatch(10);

        for (int k = 0; k < 10; k++) {
            int finalK = k;
            pool.submit(() -> {
                for (int i = 0; i <= 100; i++) {
                    try {
                        TimeUnit.MILLISECONDS.sleep(random.nextInt(100));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    all[finalK] = i + "%";
                    System.out.print("\r" + Arrays.toString(all)); // 前面 + "\r" 可以实现不换行打印
                }
                latch.countDown();
            });
        }

        latch.await();
        System.out.println("\n 游戏开始");
        pool.shutdown();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    在这里插入图片描述

    12.6.4 应用2（同步等待多个远程调用结束）

    获取带返回值的调用方法就可以用 Future 来接收。

    具体参照：https://www.bilibili.com/video/BV16J411h7Rd?p=270

    12.7 CyclicBarrier

    12.7.1 引例：实现两个任务，连续执行三次，每次执行后都需要做结果汇总

    循环三次，每次都创建一个 CountDownLatch

    @Slf4j(topic = "c.InitTest")
public class InitTest {
    @SneakyThrows
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 3; i++) {
            CountDownLatch latch = new CountDownLatch(2);

            pool.submit(() -> {
                log.debug("task1 start...");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                latch.countDown();
            });
            
            pool.submit(() -> {
                log.debug("task2 start...");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                latch.countDown();
            });

            latch.await();
            log.debug("finish...");
        }
        pool.shutdown();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    没有实现 CountDownLatch 的重用。

    12.7.2 引入 CyclicBarrier

    循环栅栏，用来进行线程协作，等待线程满足某个计数。构造时设置 计数个数，每个线程执行到某个需要 同步 的时刻调用 await() 方法进行等待，当等待的线程满足 计数个数 时，继续执行

    每次计数减到 0，进行汇总后，下一次继续从设置的初始次数进行。实现了重用 CyclicBarrier 对象。

    @Slf4j(topic = "c.InitTest")
public class InitTest {
    @SneakyThrows
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        CyclicBarrier barrier = new CyclicBarrier(2, () -> {
            log.debug("finish!");
        });

        for (int i = 0; i < 3; i++) {
            pool.submit(() -> {
                log.debug("task1 start...");
                try {
                    TimeUnit.SECONDS.sleep(1);
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }
            });

            pool.submit(() -> {
                log.debug("task2 start...");
                try {
                    TimeUnit.SECONDS.sleep(2);
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }
            });
        }

        pool.shutdown();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    在这里插入图片描述

    12.7.3 注意线程池数量要和 CyclicBarrier 循环次数相同

    假如说我设置线程池数量为 3，就会造成第一次循环的 task1 和第二次循环的 task1 任务汇总：
    在这里插入图片描述

  • 相关阅读:
    单基因泛癌+实验简单验证，要素丰富，没研究方向的赶紧上车
    Redis 事务
    Linux调度域与调度组
    MySQL性能调优关注点和思路
    1-烷基-3-甲基咪唑六氟磷酸盐[CnMIm][PF6](其中n=4,6,8,10,12)齐岳离子液体
    SpringBoot--使用@RequestHeader获取请求头
    跟单王订单追踪软件如何打通金蝶ERP？
    Hospital Management Startup 1.0 SQL 注入漏洞（CVE-2022-23366）
    javaScript 的 this 究竟是个什么鬼？
    有能帮我看看这个怎么恢复吗？
  • 原文地址：https://blog.csdn.net/qq_39906884/article/details/127674025