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

最新推荐文章于 2024-01-20 10:15:42 发布
最新推荐文章于 2024-01-20 10:15:42 发布
阅读量337 收藏
点赞数
分类专栏： JUC 文章标签： java 数据库 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39906884/article/details/127674025
版权

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();
    }
}

在这里插入图片描述

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();
        }

    }
}

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

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

在这里插入图片描述

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);
        }
    }
}

在这里插入图片描述

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

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();
        }
    }
}

在这里插入图片描述

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 + '\'' +
                '}';
    }
    /**
	 * 省略实现方法。。。。
	*/
}

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...");
    }
}

在这里插入图片描述

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...");
        });
    }
}
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();
    }
}

在这里插入图片描述

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();
    }
}

没有实现 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();
    }
}

在这里插入图片描述

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

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

哇咔咔负负得正
关注
专栏目录
StampLock使用（乐观读，锁升级）
qq_41911762的博客
11-03 1294
package stamplock; import java.util.concurrent.locks.StampedLock; /** * 所有获取锁的方法，都返回一个邮戳（Stamp），Stamp为0表示获取失败，其余都表示成功； * 所有释放锁的方法，都需要一个邮戳（Stamp），这个Stamp必须是和成功获取锁时得到的Stamp一致； * StampedLock是不可重入的；...
JUC系列之CyclicBarrier/CountDownLatch/Semaphore
曾经沧海难为水的博客
09-07 720
CyclicBarrier 同步屏障，如果有人问你如何让N个线程同时之行某件事，请告诉他CyclicBarrier 那么他是如何来确保这一点的呢？ 通过await使所有线程进入barrier。当达到预设计数器或await timeout 条件时，所有await线程开始继续执行 结合场景来说，今天我们要去抢火车票。我们为了公平起见，告诉大家今天中午12点开始放票，大家都在12点以前进
StampLock
batman
11-15 369
在 JDK 1.8 引入 StampedLock，可以理解为对 ReentrantReadWriteLock在某些方面的增强，在原先读写锁的基础上新增了一种叫乐观读（Optimistic Reading）的模式。
StampedLockd实现读写锁
renguiriyue的博客
04-02 252
廖雪峰老师的亲笔，我偷来的知识 转载：https://www.liaoxuefeng.com/wiki/1252599548343744/1309138673991714 前面介绍的ReadWriteLock可以解决多线程同时读，但只有一个线程能写的问题。 如果我们深入分析ReadWriteLock，会发现它有个潜在的问题：如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁，即读的过程中不...
邮戳锁StampLock
xiaoxishuaidaile的博客
11-25 1303
基本理论 所有获取锁的方法，都返回一个邮戳（Stamp），Stamp为0表示获取失败，其余都表示成功； 所有释放锁的方法，都需要一个邮戳（Stamp），这个Stamp必须是和成功获取锁时得到的Stamp一致； StampedLock是不可重入的；（如果一个线程已经持有了写锁，再去获取写锁的话就会造成死锁） StampedLock有三种访问模式： Reading（读模式）：功能和ReentrantReadWriteLock的读锁类似 Writing（写模式）：功能和ReentrantReadWr
StampLock：一种高效的并发锁机制
最新发布
小阳同学的博客
01-20 521
在多线程编程中，并发控制是确保数据一致性和避免冲突的关键。ReentrantReadWriteLock 是 Java 中的一个常用工具，它提供了读写锁的功能，使得多个线程可以同时读取共享资源，但在写入时则需要独占式的访问。然而，在某些情况下，ReentrantReadWriteLock 的性能可能并不理想。为了解决这个问题，Java 8 引入了一个新的并发工具 StampedLock。
java并发编程：juc、aqs
08-09
`AQS`(AbstractQueuedSynchronizer)是JUC库中的一个关键组件，它是一个抽象基类，为构建自定义的同步器提供了基础框架。AQS通过内部维护一个基于链表的等待队列，有效地管理线程的同步和唤醒，从而实现锁和其他同步...
终于有人把 CountDownLatch，CyclicBarrier，Semaphore 讲明白了！
烟雨星空的博客
03-06 639
在 JUC 下包含了一些常用的同步工具类，今天就来详细介绍一下，CountDownLatch，CyclicBarrier，Semaphore 的使用方法以及它们之间的区别。 一、CountDownLatch 先看一下，CountDownLatch 源码的官方介绍。 意思是，它是一个同步辅助器，允许一个或多个线程一直等待，直到一组在其他线程执行的操作全部完成。 public CountDownLa...
Java 多线程与并发(10-26)-JUC锁- 锁核心类AQS详解.pdf
07-23
它是实现Java并发包中锁和其他同步器的基础框架，例如ReentrantLock（可重入锁）、Semaphore（信号量）、CountDownLatch（倒计时门闩）、CyclicBarrier（循环栅栏）以及ReentrantReadWriteLock（可重入读写锁）等。...
CountDownLatch,CyclicBarrier,Semaphore的使用及底层实现
阿福聊编程
10-07 386
JUC 并发工具类
Java8新特性之StampedLock_动力节点Java学院整理
08-30
本文从synchronized、Lock到Java8新增的StampedLock进行对比分析，对Java8新特性之StampedLock相关知识感兴趣的朋友一起看看吧
java锁 StampedLock
bml_bml_的博客
08-10 964
StampedLock源码分析
高性能读写锁StampedLock
qq_31391225的博客
11-26 283
ReentrantReadWriteLock 的性能已经很好了但是他底层还是需要进行一系列的cas操作去加锁； StampedLock如果是读锁上锁是没有这种cas操作的性能比ReentrantReadWriteLock 更好 也称为乐观读锁；即读获取锁的时候 是不加锁 直接返回一个值；然后执行临界区的时候去验证这个值是 否有被人修改（写操作加锁） 如果没有被人修改则直接执行临界区的代码；如果被人修改了则需要升级为读写锁 (ReentrantReadWriteLock--->readLock); 基本
StampedLock浅析
潘建南的博客
12-19 2905
所谓的乐观读模式，也就是若读的操作很多，写的操作很少的情况下，可以乐观地认为，写入与读取同时发生几率很少，因此不悲观地使用完全的读取锁定，程序可以查看读取资料之后，判断是否发生写入执行的变更，再采取后续的措施（重新读取变更信息，或者抛出异常） ，这一个小小改进，可大幅度提高程序的吞吐量！StampedLock 可以说是Lock的一个很好的补充，吞吐量以及性能上的提升足以打动很多人了，但并不是说要替代之前Lock的东西，毕竟他还是有些应用场景的，起码API比StampedLock容易入手。
StampedLock详解
qq_40276626的博客
08-23 4015
StampedLock简介 StampedLock是比ReentrantReadWriteLock更快的一种锁，支持乐观读、悲观读锁和写锁。和ReentrantReadWriteLock不同的是，StampedLock支持多个线程申请乐观读的同时，还允许一个线程申请写锁。 StampedLock的底层并不是基于AQS的。 StampedLock示例 class Point { private double x, y; private final StampedLock sl = new S
《Java高并发程序设计》学习 --6.6 读写锁的改进：StampedLock
sunhaoning的专栏
03-31 1940
StamppedLock是Java 8中引入的一种新的锁机制。读写锁虽然分离了读和写的功能，使得读与读之间可以完全并发。但是，读和写之间依然是冲突的。读锁会完全阻塞写锁，它使用的依然是悲观锁的策略，如果有大量的读线程，它也有可能引起写线程的“饥饿”。 而StampedLock提供了一种乐观的读策略。这种乐观策略的锁非常类似无锁的操作，使得乐观锁完全不会阻塞写线程。 1）StampedLock使
StampedLock介绍和实现原理,代码演示
java架构师分享,有问题可以联系我
03-24 281
StampedLock介绍和实现原理,代码演示
StampedLock类的高级锁
西木空间
11-26 540
StampedLock类的高级锁准备工作实现过程工作原理扩展学习更多关注 与Lock或者ReadWriteLock接口提供的锁机制都不同，StampedLock类提供了一种特殊的锁。事实上，StampedLock类不实现这些接口，但其提供的功能相似。 首先要注意的是这种锁的主要目的是作为帮助类实现线程安全组件，所以在标准的应用中并不多见。 StampedLock锁最重要的特性如下所示： 三种不同...
详解锁StampedLock
weixin_39098944的博客
06-13 660
读写锁：允许多个线程同时读，但是只允许一个线程写，在线程获取到写锁的时候，其他写操作和读操作都会处于阻塞状态，读锁和写锁也是互斥的，所以在读的时候是不允许写的，那如何实现一个读写锁呢？ 读写锁比传统的synchronized速度要快很多，原因就是在于读写锁支持读并发，而synchronized要求所有操作都是串行化，对知识的渴望在不断的增加，所以我们就不断的在想这么一个问题，读写锁的读和写是互斥，那我们能不能做到读和写支持并发呢？答案是肯定的，于是StampedLock横空出世 StampedLock St
Java并发编程深度解析：JUC与AQS核心机制
Semaphore（信号量）、CountDownLatch、CyclicBarrier等都是共享锁的例子，它们可以控制多个线程的并发数。 AQS的关键方法包括： - `tryAcquire(int)`：尝试独占资源，成功返回true，失败返回false。 - `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哇咔咔负负得正

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值