前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >线程的三个同步器

线程的三个同步器

作者头像
晚上没宵夜
发布2020-04-13 12:02:00
5170
发布2020-04-13 12:02:00
举报
文章被收录于专栏:Howl同学的学习笔记

1. CountDownLatch

日常中会有开启多个线程去并发执行任务,而主线程要等所有子线程执行完之后才能运行的需求。之前我们是使用Thread.join方法来实现的,过程如下:

代码语言:javascript
复制
public static void main(String[] args) throws InterruptedException {

    Thread t1 = new Thread( () -> {
        try {
            Thread.sleep(1000);
            System.out.println("t1 over");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    Thread t2 = new Thread( () -> {
        try {
            Thread.sleep(2000);
            System.out.println("t2 over");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    t1.start();
    t2.start();
    
    t1.join();
    t2.join();

    System.out.println("mian over");
}
代码语言:javascript
复制
t1 over
t2 over
mian over

join()方法不够灵活,现在JDK提供了CountDownLatch这个类来实现所需功能

代码语言:javascript
复制
private static CountDownLatch countDownLatch = new CountDownLatch(2);

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

    ExecutorService t = Executors.newCachedThreadPool();

    Runnable r1 = () -> {
        try {
            System.out.println("r1 sleep");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            countDownLatch.countDown();
        }
    };

    Runnable r2 = () -> {
        try {
            System.out.println("r2 sleep");
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            countDownLatch.countDown();
        }
    };

    t.submit(r1);
    t.submit(r2);

    System.out.println("main wait");
    countDownLatch.await();
    System.out.println("main over");
}
代码语言:javascript
复制
main wait
r1 sleep
r2 sleep
main over

CountDownLatch流程:

  • 新建CountDownLatch实例,传入计数器次数
  • 主线程调用CountDownLatch.await()方法后会被阻塞
  • 子线程中在某处调用CountDownLatch.countDown()方法可使内部计数器减1
  • 当计数器变成0时,主线程的await()方法才会返回

CountDownLatch优点:

  • 调用Thread.join()调用线程会被阻塞至子线程运行完毕,而CountDownLatch.countDown()可在线程运行中执行
  • 使用线程池时是提交任务的,而没有接触到线程无法使用线程方法,那么countDown()可加在Runnable中执行

CountDownLatch原理:

内部维护了一个计数器,当计数器为0就放行,源码就不放了,熟悉AQS的同学想想就知道怎么回事

  • 继承了AQS,其实就是用AQS的state来表示计数器
  • await()方法内部有acquireSharedInterruptibly(),后者调用了重写tryaquireShared()其实就是判断计数器是否为0,不为0则阻塞进AQS队列
  • countDown()方法内部有releaseShared(),后者调用了重写tryReleaseShared()计数器减一,若为0,则唤醒阻塞线程

2. CyclicBarrier

满足多个线程都到达同一个位置后才全部开始运行的需求。CountDownLatch是一次性使用的,计数器为0后再次调用会直接返回,此时升级版的CyclicBarrier来了,其一可以满足计数器重置功能,且二还可以让一组线程达到一个状态后再全部同时执行

场景要求:假设一个任务分为3个阶段,每个线程要串行地从低阶段执行到高阶段

代码语言:javascript
复制
private static CyclicBarrier cyclicBarrier = new CyclicBarrier(2, 
                        () -> System.out.println("一个阶段完成"));

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

    ExecutorService service = Executors.newCachedThreadPool();

    Runnable r1 = () -> {
        try {
            System.out.println(Thread.currentThread() + "Step1");
            cyclicBarrier.await();

            System.out.println(Thread.currentThread() + "Step2");
            cyclicBarrier.await();

            System.out.println(Thread.currentThread() + "Step3");

        } catch (Exception e) {
            e.printStackTrace();
        }
    };

    Runnable r2 = () -> {
        try {
            System.out.println(Thread.currentThread() + "Step1");
            cyclicBarrier.await();

            System.out.println(Thread.currentThread() + "Step2");
            cyclicBarrier.await();

            System.out.println(Thread.currentThread() + "Step3");

        } catch (Exception e) {
            e.printStackTrace();
        }
    };

    service.submit(r1);
    service.submit(r2);

    service.shutdown();
}
代码语言:javascript
复制
Thread[pool-1-thread-1,5,main]Step1
Thread[pool-1-thread-2,5,main]Step1
一个阶段完成
Thread[pool-1-thread-1,5,main]Step2
Thread[pool-1-thread-2,5,main]Step2
一个阶段完成
Thread[pool-1-thread-1,5,main]Step3
Thread[pool-1-thread-2,5,main]Step3

CyclicBarrier的流程

  • 和上面差不多就不一一解释了
  • CyclicBarrier的构造方法中,第一个参数为计数器次数,第二个为阶段结束后要执行的方法

CyclicBarrier的原理

  • 基于独占锁,底层是AQS实现,独占锁可以原子性改变计数器,以及条件队列阻塞线程来实现线程同步
  • 内部有parties和count变量,实现重置功能
  • await()方法内调用dowait()方法
    • 获取锁更新次数减一
    • 没有为0,阻塞当前线程加入条件队列
    • 为0执行屏蔽点任务,然后唤醒条件队列的全部线程

3. Semaphore

不同与前两者,Semaphore信号量内部计数器是递增的,在需要同步的地方调用acquire指定需要同步的个数即可

代码语言:javascript
复制
private static Semaphore semaphore = new Semaphore(0);

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

    ExecutorService service = Executors.newCachedThreadPool();

    Runnable r1 = () -> {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread() + "over");
        semaphore.release();;
    };

    Runnable r2 = () -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread() + "over");
        semaphore.release();
    };

    service.submit(r1);
    service.submit(r2);

    semaphore.acquire(2);
    System.out.println("All child thread over");

    service.shutdown();
}

Semaphore的流程

  • Semaphore的构造函数传参复制当前计数器的值
  • 每个线程内部调用release()即计数器加1
  • 主线程调用acquire()方法传参为2 ,会被阻塞至计数器到达2

Semaphore的原理

  • 底层还是使用AQS,提供了公平与非公平,也是用state表示次数
  • acquire()方法获取一个信号量,并且state减一
    • 若为0,直接返回
    • 不为0当前线程会被加入AQS阻塞队列
  • release()方法,把当前Semaphore的信号量加1,然后会选择一个信号量满足的线程进行激活
  • 内部还实现了公平与非公平策略
本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2020-04-12 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 1. CountDownLatch
  • 2. CyclicBarrier
  • 3. Semaphore
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档