目录

背景

独占锁与共享锁

独占锁

共享锁

公平锁与非公平锁

公平锁

非公平锁

可重入锁

总结

---

背景

最近有一些小伙伴会问我一些关于并发相关的问题，在与他们的沟通中，我发现他们对锁的概念很模糊。这部分基础概念的缺失导致他们写的程序经常死锁，还无法bebug。虽然在网上有很多资料，但我还是用一些比较通俗易懂的例子，描述一下，帮助大家理解。

独占锁与共享锁

我发现很多人会把独占锁与公平锁搞混，其实他们不在一个方向上。

独占锁

独占锁是指在同一个时间只能有一个线程占有他，所以具备排他性。像synchronized关键字就是典型的独占锁。

举个栗子：独占锁相当于独间的澡堂，一个人进了这件澡堂，其他人都不能进，只有等他出来。

共享锁

什么是共享锁？

就是指同一时间可以被多个线程占有，像java自带的ReadWriteLock、Semaphore，他们可以设置自己共享的数量。

举个栗子：共享锁相当于一个大型公共澡堂，一开始就设定了能进去洗澡人的数量，比如是10个人，那么你要进去的时候会检查一下有没有满10个，满了你就在门口排队去吧。

公平锁与非公平锁

如果你在排队买奶茶，有个人插队了但是没人制止，你生不生气？他买到了奶茶扬长而去，这公不公平。

公平锁

公平锁就是多个线程去申请锁的使用权的时候，线程会直接进入队列排队，排在前面的可以先获得锁，排在后面的只能等着前面的先用。

举个栗子：有个澡堂，里面已经满了，后面的人想冲进去。但是有个保安站在门口，他让后面想进来的人都排好队，出来一个，就从队伍的前面放一个人进去。

没错，这就很公平。

但是公平锁也会带来其他的缺点，就是需要一个保安去控制，带来的其他开销。如果大家蜂拥而至去抢位置，少了这个保安，会更有效率。没错公平锁的缺点就是会带来更大的开销以及吞吐量下降。

非公平锁

与公平锁对应的就是非公平了，简而言之就是和公平锁反正来，什么不公平来什么。关键字synchronized就是典型的非公平锁。

缺点就是不公平，在某些场景中，特别是每次获取锁后会迅速执行并且释放锁的情况下，非公平锁是可以使用的。假设你洗澡的时间巨长，还有人插我队，这谁能忍得了？

可重入锁

可重入锁的概念很多人容易理解错，他是指同一个线程在申请到锁的情况下，继续申请锁不会阻塞，而是有个计数器记录该线程以及线程申请的次数。

举个栗子：还是单间浴室，但是我有一个洗澡卡，一旦我进了洗澡间就要刷卡，而且出来的时候还需要刷卡退出。那么我一旦进了洗澡间，我可以刷好几次进入卡，这不会阻塞住，因为都是我自己刷的。但是我退出洗澡间的时候我得刷同样次数的退出卡，不然下一个进来的人刷不了进入卡。好理解吗？你也别管我刷几次，反正我刷几次进入，就刷几次退出。

像java的关键字synchronized和ReentrantLock类都是可重入锁。

总结

希望这些简单的栗子可以帮主你理解java一些锁知识，不要把生硬的文字过度理解，跳出文字本身，设想一些生活中的场景，可以帮助我们更好的理解知识。

分享：

        知识有两种，其一是我们自己精通的问题；其二是我们知道在哪里找到关于某问题的知识。                                                                                        ——约翰生

如果本文对你有用的话，请点个赞吧，谢谢！

问题：
1、Semaphore有什么作用？
2、CyclicBarrier和CountDownLatch的用法及区别
3、三个线程a、b、c并发运行，b，c需要a线程的数据怎么实现?
4、怎么控制同一时间只有 3 个线程运行？

1. 独占锁

独占锁也叫排他锁、互斥锁、独享锁，是指锁在同一时刻只能被一个线程所持有。一个线程加锁后，任何其他试图再次加锁的线程都会被阻塞，直到持有锁线程解锁。通俗来说，就是共享资源某一时刻只能有一个线程访问，其余线程阻塞等待。

如果是公平地独占锁，在持有锁线程解锁时，如果有一个以上的线程在阻塞等待，那么最先抢锁的线程被唤醒变为就绪状态去执行加锁操作，其他的线程仍然阻塞等待。

java中的Synchronized内置锁和ReentrantLock显式锁都是独占锁。

2. 共享锁

共享锁就是在同一时刻允许多个线程持有的锁。当然，获得共享锁的线程只能读取临界区的数据，不能修改临界区的数据。

JUC中的共享锁包括Semaphore（信号量）、ReadLock（读写锁）中的读锁、CountDownLatch倒数闩。

2.1 Semaphore

Semaphore用来限制能同时访问共享资源的线程上限。

Semaphore可以用来控制在同一时刻访问共享资源的线程数量，通过协调各个线程以保证共享资源的合理使用。Semaphore维护了一组虚拟许可，它的数量可以通过构造器的参数指定。线程在访问共享资源前必须调用Semaphore的acquire()方法获得许可，如果许可数量为0，该线程就一直阻塞。线程访问完资源后，必须调用Semaphore的release()方法释放许可。更形象的说法是：Semaphore是一个许可管理器。

Semaphore类的主要方法大致如下：

(1) Semaphore(permits)：构造一个Semaphore实例，初始化其管理的许可数量为permits参数值。

(2) Semaphore(permits,fair)：构造一个Semaphore实例，初始化其管理的许可数量为permits参数值，以及是否以公平模式（fair参数是否为true）进行许可的发放。

Semaphore和ReentrantLock类似，Semaphore发放许可时有两种模式：公平模式和非公平模式，默认情况下使用非公平模式。

(3) availablePermits()：获取Semaphore对象可用的许可数量。

(4) acquire()：当前线程尝试获取Semaphore对象的一个许可。此过程是阻塞的，线程会一直等待Semaphore发放一个许可，直到发生以下任意一件事：

• 当前线程获取了一个可用的许可。
• 当前线程被中断，就会抛出InterruptedException异常，并停止等待，继续往下执行。

(5) acquire(permits)：当前线程尝试阻塞地获取permits个许可。此过程是阻塞的，线程会一直等待Semaphore发放permits个许可。如果没有足够的许可而当前线程被中断，就会抛出InterruptedException异常并终止阻塞。

(6) acquireUninterruptibly()：当前线程尝试阻塞地获取一个许可，阻塞的过程不可中断，直到成功获取一个许可。

(7) acquireUninterruptibly(permits)：当前线程尝试阻塞地获取permits个许可，阻塞的过程不可中断，直到成功获取permits个许可。

(8) tryAcquire()：当前线程尝试获取一个许可。此过程是非阻塞的，它只是进行一次尝试，会立即返回。如果当前线程成功获取了一个许可，就返回true；如果当前线程没有获得许可，就返回false

(9) tryAcquire(permits)：当前线程尝试获取permits个许可。此过程是非阻塞的，它只是进行一次尝试，会立即返回。如果当前线程成功获取了permits个许可，就返回true；如果当前线程没有获得permits个许可，就返回false。

(10) tryAcquire(timeout,TimeUnit)：限时获取一个许可。此过程是阻塞的，会一直等待许可，直到发生以下任意一件事：

• 当前线程获取了一个许可，则会停止等待，继续执行，并返回true。
• 当前线程等待timeout后超时，则会停止等待，继续执行，并返回false。
• 当前线程在timeout时间内被中断，则会抛出InterruptedException异常，并停止等待，继续执行。

(11) tryAcquire(permits,timeout,TimeUnit)：与tryAcquire(timeout,TimeUnit)方法在逻辑上基本相同，不同之处在于：在获取许可的数量上不同，此方法用于获取permits个许可。

(12) release()：当前线程释放一个可用的许可。

(13) release(permits)：当前线程释放permits个可用的许可。

(14) drainPermits()：当前线程获得剩余的所有可用许可。

(15) hasQueuedThreads()：判断当前Semaphore对象上是否存在正在等待许可的线程。

(16) getQueueLength()：获取当前Semaphore对象上正在等待许可的线程数量。

共享锁使用示例 ：

@Slf4j
public class TestSemaphore {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        for(int i=0;i<10;i++){
            new Thread(()->{
                try {
                    // 获取许可
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 睡眠1s
                try {
                    log.debug("running.....");
                    Thread.sleep(1000);
                    log.debug("end.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            }).start();
        }
    }
}

执行结果：

17:36:28.044 [Thread-1] DEBUG com.example.aa.TestSemaphore - running.....
17:36:28.047 [Thread-0] DEBUG com.example.aa.TestSemaphore - running.....
17:36:28.047 [Thread-2] DEBUG com.example.aa.TestSemaphore - running.....
17:36:29.047 [Thread-0] DEBUG com.example.aa.TestSemaphore - end.....
17:36:29.047 [Thread-2] DEBUG com.example.aa.TestSemaphore - end.....
17:36:29.047 [Thread-3] DEBUG com.example.aa.TestSemaphore - running.....
17:36:29.047 [Thread-4] DEBUG com.example.aa.TestSemaphore - running.....
17:36:29.047 [Thread-1] DEBUG com.example.aa.TestSemaphore - end.....
17:36:29.047 [Thread-5] DEBUG com.example.aa.TestSemaphore - running.....
17:36:30.047 [Thread-4] DEBUG com.example.aa.TestSemaphore - end.....
17:36:30.047 [Thread-5] DEBUG com.example.aa.TestSemaphore - end.....
17:36:30.047 [Thread-6] DEBUG com.example.aa.TestSemaphore - running.....
17:36:30.047 [Thread-3] DEBUG com.example.aa.TestSemaphore - end.....
17:36:30.047 [Thread-7] DEBUG com.example.aa.TestSemaphore - running.....
17:36:30.047 [Thread-8] DEBUG com.example.aa.TestSemaphore - running.....
17:36:31.047 [Thread-7] DEBUG com.example.aa.TestSemaphore - end.....
17:36:31.047 [Thread-8] DEBUG com.example.aa.TestSemaphore - end.....
17:36:31.047 [Thread-6] DEBUG com.example.aa.TestSemaphore - end.....
17:36:31.047 [Thread-9] DEBUG com.example.aa.TestSemaphore - running.....
17:36:32.048 [Thread-9] DEBUG com.example.aa.TestSemaphore - end.....

2.2 CountDownLatch

用来进行线程同步协作，等待所有线程完成倒计时。 其中构造参数用来初始化等待计数值，await() 用来等待计数归零，countDown() 用来让计数减一。

CountDownLatch可以指定一个计数值，在并发环境下由线程进行减一操作，当计数值变为0之后，被await方法阻塞的线程将会唤醒。通过CountDownLatch可以实现线程间的计数同步。

@Slf4j
public class TestCountDownLatch {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        new Thread(()->{
            log.debug("begin...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 计数减1
            countDownLatch.countDown();
            log.debug("end...");
        }).start();

        new Thread(()->{
            log.debug("begin...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 计数减1
            countDownLatch.countDown();
            log.debug("end...");
        }).start();

        new Thread(()->{
            log.debug("begin...");
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 计数减1
            countDownLatch.countDown();
            log.debug("end...");
        }).start();
        
        log.debug("waiting...");
        // await() 用来等待计数归零
        countDownLatch.await();
        // 当计数值变为0之后，被await方法阻塞的线程将会唤醒
        log.debug("waiting end....");
    }
}

执行结果：

19:23:34.930 [pool-1-thread-2] DEBUG com.example.aa.TestCountDownLatch - begin...
19:23:34.930 [pool-1-thread-3] DEBUG com.example.aa.TestCountDownLatch - begin...
19:23:34.930 [pool-1-thread-1] DEBUG com.example.aa.TestCountDownLatch - begin...
19:23:34.932 [pool-1-thread-4] DEBUG com.example.aa.TestCountDownLatch - waiting...
19:23:35.933 [pool-1-thread-1] DEBUG com.example.aa.TestCountDownLatch - end...2
19:23:36.432 [pool-1-thread-3] DEBUG com.example.aa.TestCountDownLatch - end...1
19:23:36.933 [pool-1-thread-2] DEBUG com.example.aa.TestCountDownLatch - end...0
19:23:36.933 [pool-1-thread-4] DEBUG com.example.aa.TestCountDownLatch - waiting end....

可以配合线程池使用，改进如下:

@Slf4j
public class TestCountDownLatch {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        executorService.submit(()->{
            log.debug("begin...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 计数减1
            countDownLatch.countDown();
            log.debug("end...{}",countDownLatch.getCount());
        });

        executorService.submit(()->{
            log.debug("begin...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 计数减1
            countDownLatch.countDown();
            log.debug("end...{}",countDownLatch.getCount());
        });

        executorService.submit(()->{
            log.debug("begin...");
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 计数减1
            countDownLatch.countDown();
            log.debug("end...{}",countDownLatch.getCount());
        });

        executorService.submit(()->{
            log.debug("waiting...");
            // await() 用来等待计数归零
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 当计数值变为0之后，被await方法阻塞的线程将会唤醒
            log.debug("waiting end....");
        });
    }
}

结合上述示例的运行结果，梳理一下CountDownLatch的使用步骤：

（1）创建倒数闩，初始化CountDownLatch时设置倒数的总次数，比如为3。

（2）等待线程调用倒数闩的await()方法阻塞自己，等待倒数闩的计数器数值为0（倒数线程全部执行结束）。

（3）倒数线程执行完，调用CountDownLatch.countDown()方法将计数器数值减一。

2.3 CyclicBarrie

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

@Slf4j
public class TestCountDownLatch {
    public static void main(String[] args) throws InterruptedException {
        CyclicBarrier cb = new CyclicBarrier(2); // 个数为2时才会继续执行
        new Thread(()->{
            System.out.println("线程1开始.."+new Date());
            try {
                cb.await(); // 当个数不足时，等待
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("线程1继续向下运行..."+new Date());
        }).start();
        new Thread(()->{
            System.out.println("线程2开始.."+new Date());
            try { Thread.sleep(2000); } catch (InterruptedException e) { }
            try {
                cb.await(); // 2 秒后，线程个数够2，继续运行
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("线程2继续向下运行..."+new Date());
        }).start();
    }
}

执行结果：

线程1开始..Mon Mar 28 19:32:21 CST 2022
线程2开始..Mon Mar 28 19:32:21 CST 2022
线程2继续向下运行...Mon Mar 28 19:32:23 CST 2022
线程1继续向下运行...Mon Mar 28 19:32:23 CST 2022

CyclicBarrier 与 CountDownLatch 的主要区别在于 CyclicBarrier 是可以重用的，CyclicBarrier 可以被比 喻为『人满发车』

Semaphore、CountDownLatch二者都是基于共享锁实现的，用于在线程之间进行操作同步的工具类。JUC的同步工具类一共有3个：Semaphore、CountDownLatch和CyclicBarrier。