多线程工具类：CountDownLatch、CyclicBarrier、Semaphore、LockSupport

以你之姓@ 2024-04-18 20:25 103阅读 0赞

◆

CountDownLatch

◆

假如有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以。

比如你想要买套房子，但是呢你现在手上没有钱。你得等这个月工资发了、然后年终奖发了、然后朋友借你得钱还给你了、然后再给朋友借一部分才可以买，这种场景你就可以使用CountDownLatch。

CountDownLatch是JDK为我们提供的一个计数器，它的操作是原子操作，同一时间只能有一个线程去操作这个它。

我们先来看一下CountDownLatch的主要方法。

//构造方法，接收计数器的数量	
    public CountDownLatch(int count)	
    //持续等待计数器归零	
    public void await()	
    //最多等待unit时间单位内timeout时间	
    public boolean await(long timeout, TimeUnit unit)	
    //计数器减1	
    public void countDown()	
    //返回现在的计数器数量	
    public long getCount()

下面是CountDownLatch的基本使用示例代码：

public class CountDownLatchDemo {	
        public static CountDownLatch countDownLatch = new CountDownLatch(5);	
        static class ThreadDemo extends Thread {	
            @Override	
            public void run() {	
                try {	
                    Thread.sleep(1000);	
                } catch (InterruptedException e) {	
                    e.printStackTrace();	
                }	
                System.out.println(Thread.currentThread().getId() + "完成任务");	
                countDownLatch.countDown();	
            }	
        }	
        public static void main(String[] args) throws InterruptedException {	
            for (int i = 0; i < 5; i++) {	
                new ThreadDemo().start();	
            }	
            countDownLatch.await();	
            System.out.println("全部完成任务");	
        }	
    }

◆

CyclicBarrier

◆

相比较于CountDownLatch，CyclicBarrier可以完成前者的全部功能，但是相比前者，它的功能更加的强大。

1.  CyclicBarrier翻译过来的中文名称叫循环栅栏，顾名思义它可以循环使用
2.  CyclicBarrier还可以接收一个Runnable对象，当栅栏循环一次技术后会执行一次Runnable

我们来看一下CyclicBarrier的常用方法：

//构造方法，第一个参数为栅栏饿长度，第二个就是上方所说的Runnable对象	
    public CyclicBarrier(int parties, Runnable barrierAction)	
    public CyclicBarrier(int parties)	
    //获取现在的数量	
    public int getParties()	
    //持续等待栅栏归零	
    public int await()	
    //最多等待unit时间单位内timeout时间	
    public int await(long timeout, TimeUnit unit)

下面是CyclicBarrier的基本使用示例代码：

public class CyclicBarrierDemo {	
        public static CyclicBarrier cyclicBarrier = new CyclicBarrier(5,new FinallyThreadDemo());	
        static class ThreadDemo extends Thread {	
            @Override	
            public void run() {	
                try {	
                    Thread.sleep(1000);	
                    System.out.println(Thread.currentThread().getId() + "完成任务");	
                    cyclicBarrier.await();	
                } catch (InterruptedException e) {	
                    e.printStackTrace();	
                } catch (BrokenBarrierException e) {	
                    e.printStackTrace();	
                }	
                System.out.println("到达屏障点每个线程都会瞬时继续执行");	
            }	
        }	
        static class FinallyThreadDemo extends Thread {	
            @Override	
            public void run() {	
                System.out.println("所有任务已经完成之后单独执行的任务！");	
            }	
        }	
        public static void main(String[] args) throws InterruptedException {	
            for (int i = 0; i < 10; i++) {	
                new ThreadDemo().start();	
            }	
        }	
    }

观察打印结果我们可以发现：

当循环栅栏的任务执行完一轮以后，如果构造时传入了Runnable对象，则先执行Runnable对象，然后在瞬间释放所有任务的锁。

14完成任务	
    15完成任务	
    16完成任务	
    17完成任务	
    18完成任务	
    所有任务已经完成之后单独执行的任务！	
    到达屏障点每个线程都会瞬时继续执行	
    到达屏障点每个线程都会瞬时继续执行	
    到达屏障点每个线程都会瞬时继续执行	
    到达屏障点每个线程都会瞬时继续执行	
    到达屏障点每个线程都会瞬时继续执行	
    19完成任务	
    20完成任务	
    21完成任务	
    22完成任务	
    23完成任务	
    所有任务已经完成之后单独执行的任务！	
    到达屏障点每个线程都会瞬时继续执行	
    到达屏障点每个线程都会瞬时继续执行	
    到达屏障点每个线程都会瞬时继续执行	
    到达屏障点每个线程都会瞬时继续执行	
    到达屏障点每个线程都会瞬时继续执行

◆

Semaphore

◆

在  [浅谈Java中的锁：Synchronized、重入锁、读写锁][Java_Synchronized] 一文中，我们了解了synch和读写锁，我们发现使用锁的时候一次只允许一条线程方法。那么有什么东西可以提供更强大的控制方法么？这个东西就是信号量。

信号量提供的主要方法：

//创建具有给定许可数的信号量	
    Semaphore(int permits):构造方法，创建	
    //拿走1个许可	
    void acquire()	
    //拿走多个许可	
    void acquire(int n)	
    //释放一个许可	
    void release()	
    //释放n个许可	
    void release(int n):	
    //当前可用的许可数	
    int availablePermits()：

下面来看使用示例：

public class SemaphoreThreadDemo {	
        public static Semaphore semaphore = new Semaphore(5);	
    
    	
        static class ThreadDemo extends Thread {	
            @Override	
            public void run() {	
                try {	
                    semaphore.acquire();	
                    System.out.println(Thread.currentThread().getId() + "号线程在"+System.currentTimeMillis()+"获取资源");	
                    Thread.sleep(2000);	
                } catch (InterruptedException e) {	
                    e.printStackTrace();	
                }finally {	
                    semaphore.release();	
                }	
            }	
        }	
    
    	
        public static void main(String[] args) throws InterruptedException {	
            for (int i = 0; i < 30; i++) {	
                new ThreadDemo().start();	
            }	
        }	
    
    	
    }

◆

LockSupport

◆

我们在[ Hello，Thread][Hello_Thread] 和 [生产者消费者模型][Link 1] 两篇文章中使用过wait和notify实现了线程之间的协作，其实关于线程协作JDK还为我们提供了另外一个工具类LockSupport。

使用LockSupport实现等待通知功能时还不需要获取锁哦

先来看一下LockSupport的常用方法：

// 禁用当前线程	
    static void park()	
    // 如果参数线程的不可用，则使其可用。	
    static void unpark(Thread thread)

来看一下示例代码：

public class LockSupportThreadDemo {	
        public static Thread thread;	
        static class WaitThreadDemo extends Thread {	
            @Override	
            public void run() {	
                System.out.println("WaitThread wait,time=" + System.currentTimeMillis());	
                thread = Thread.currentThread();	
                LockSupport.park();	
                System.out.println("WaitThread end,time=" + System.currentTimeMillis());	
            }	
        }	
        static class NotifyThreadDemo extends Thread {	
            @Override	
            public void run() {	
                System.out.println("NotifyThread notify,time=" + System.currentTimeMillis());	
                LockSupport.unpark(thread);	
                try {	
                    Thread.sleep(2000);	
                } catch (InterruptedException e) {	
                    e.printStackTrace();	
                }	
                System.out.println("NotifyThread end,time=" + System.currentTimeMillis());	
            }	
        }	
        public static void main(String[] args) {	
            WaitThreadDemo waitThreadDemo = new WaitThreadDemo();	
            NotifyThreadDemo notifyThreadDemo = new NotifyThreadDemo();	
            waitThreadDemo.start();	
            try {	
                Thread.sleep(100);	
            } catch (InterruptedException e) {	
                e.printStackTrace();	
            }	
            notifyThreadDemo.start();	
        }	
    }

![640?wx\_fmt=gif][640_wx_fmt_gif]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg]

收藏转发好看再走呗!

![640?wx\_fmt=gif][640_wx_fmt_gif 1]

点击下方“阅读原文”查看源码！！！

[Java_Synchronized]: http://mp.weixin.qq.com/s?__biz=MzU5MDgzOTYzMw==&mid=2247483974&idx=1&sn=c2ea0f9bb39490dbe6fb10ac605214ce&chksm=fe396878c94ee16eea12fa691c878e74fdbd0060eda999475d927a998fbf3fe974b92e8a1a10&scene=21#wechat_redirect
[Hello_Thread]: http://mp.weixin.qq.com/s?__biz=MzU5MDgzOTYzMw==&mid=2247483972&idx=1&sn=1a7310545bc2aebbc139279bb3cb99da&chksm=fe39687ac94ee16c2366ca3054301c8e1a55db84df96f38c3bab0fb693bef6cfdcefb8f4af42&scene=21#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzU5MDgzOTYzMw==&mid=2247484000&idx=1&sn=93fd8cf93a388b87c6d4b77bb97d29fd&chksm=fe39685ec94ee1483ccfb6676fff59c22e93418d95c319c4c0e81552ac986d1174a1b99f55c6&scene=21#wechat_redirect
[640_wx_fmt_gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/51aa82d008884db9a32c3793afabf3d5.gif
[640_wx_fmt_jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/0db75bae22df4ac38e52c48bba4523b7.png
[640_wx_fmt_gif 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/3948d9220f9b43df96e4a42852d40978.gif