温故知新-多线程-forkjoin、CountDownLatch、CyclicBarrier、Semaphore用法


  • Posted by 微博@Yangsc_o
  • 原创文章,版权声明:自由转载-非商用-非衍生-保持署名 | Creative Commons BY-NC-ND 3.0

文章目录

  • 摘要
  • forkjoin
  • CountDownLatch
  • CyclicBarrier
  • Semaphore
  • 参考
  • 你的鼓励也是我创作的动力

摘要

本文主要简单介绍forkjoin、CountDownLatch、CyclicBarrier、Semaphore的常见用法;

forkjoin

从JDK1.7开始,Java提供Fork/Join框架用于并行执行任务,它的思想就是讲一个大任务分割成若干小任务,最终汇总每个小任务的结果得到这个大任务的结果。

这种思想和MapReduce很像(input --> split --> map --> reduce --> output)

主要有两步:

  • 第一、任务切分;
  • 第二、结果合并

它的模型大致是这样的:线程池中的每个线程都有自己的工作队列(PS:这一点和ThreadPoolExecutor不同,ThreadPoolExecutor是所有线程公用一个工作队列,所有线程都从这个工作队列中取任务),当自己队列中的任务都完成以后,会从其它线程的工作队列中偷一个任务执行,这样可以充分利用资源。

假如我们需要做一个比较大的任务,我们可以把这个任务分割为若干互不依赖的子任务,为了减少线程间的竞争,于是把这些子任务分别放到不同的队列里,并为每个队列创建一个单独的线程来执行队列里的任务,线程和队列一一对应,比如A线程负责处理A队列里的任务。但是有的线程会先把自己队列里的任务干完,而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着,不如去帮其他线程干活,于是它就去其他线程的队列里窃取一个任务来执行。而在这时它们会访问同一个队列,所以为了减少窃取任务线程和被窃取任务线程之间的竞争,通常会使用双端队列,被窃取任务线程永远从双端队列的头部拿任务执行,而窃取任务的线程永远从双端队列的尾部拿任务执行。

工作窃取算法的优点是充分利用线程进行并行计算,并减少了线程间的竞争,其缺点是在某些情况下还是存在竞争,比如双端队列里只有一个任务时。并且消耗了更多的系统资源,比如创建多个线程和多个双端队列。

public class ForkJoinDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new MyForkJoinTask(0L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long sum = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum=" + sum + " 时间:" + (end - start));
    }


}

class MyForkJoinTask extends RecursiveTask<Long> {

    private Long start;
    private Long end;
    // 临界值
    private Long temp = 10000L;

    public MyForkJoinTask(Long start, Long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if ((end - start) < temp) {
            Long sum = 0L;
            for (Long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        } else { // forkjoin 递归
            long middle = (start + end) / 2; 
            MyForkJoinTask task1 = new MyForkJoinTask(start, middle);
            task1.fork(); 
            MyForkJoinTask task2 = new MyForkJoinTask(middle + 1, end);
            task2.fork(); 
            return task1.join() + task2.join();
        }
    }
}

CountDownLatch

CountDownLatch 的方法不是很多,将它们一个个列举出来:

  1. await() throws InterruptedException:调用该方法的线程等到构造方法传入的 N 减到 0 的时候,才能继续往下执行;
  2. await(long timeout, TimeUnit unit):与上面的 await 方法功能一致,只不过这里有了时间限制,调用该方法的线程等到指定的 timeout 时间后,不管 N 是否减至为 0,都会继续往下执行;
  3. countDown():使 CountDownLatch 初始值 N 减 1;
  4. long getCount():获取当前 CountDownLatch 维护的值
public class CountDownLatchDemo {
    private static CountDownLatch startSignal = new CountDownLatch(1);
    //用来表示裁判员需要维护的是6个运动员
    private static CountDownLatch endSignal = new CountDownLatch(6);

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(6);
        for (int i = 0; i < 6; i++) {
            executorService.execute(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " 运动员等待裁判员响哨!!!");
                    startSignal.await();
                    System.out.println(Thread.currentThread().getName() + "正在全力冲刺");
                    endSignal.countDown();// 数量-1
                    System.out.println(Thread.currentThread().getName() + "  到达终点");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        System.out.println("裁判员发号施令啦!!!");
        startSignal.countDown(); // 数量-1
        endSignal.await();
        System.out.println("所有运动员到达终点,比赛结束!");
        executorService.shutdown();
    }

    @SneakyThrows
    public static void test0() {
        // 总数是6,必须要执行任务的时候,再使用!
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " Go out");
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        countDownLatch.await(); // 等待计数器归零,然后再向下执行
        System.out.println("Close Door");

    }
}

CyclicBarrier

当多个线程都达到了指定点后,才能继续往下继续执行。这就有点像报数的感觉,假设 6 个线程就相当于 6 个运动员,到赛道起点时会报数进行统计,如果刚好是 6 的话,这一波就凑齐了,才能往下执行。**CyclicBarrier 在使用一次后,下面依然有效,可以继续当做计数器使用,这是与 CountDownLatch 的区别之一。**这里的 6 个线程,也就是计数器的初始值 6,是通过 CyclicBarrier 的构造方法传入的。

下面来看下 CyclicBarrier 的主要方法:

// 等到所有的线程都到达指定的临界点 await() throws InterruptedException, BrokenBarrierException

// 与上面的await方法功能基本一致,只不过这里有超时限制,阻塞等待直至到达超时时间为止 await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException

//获取当前有多少个线程阻塞等待在临界点上 int getNumberWaiting()

//用于查询阻塞等待的线程是否被中断 boolean isBroken()

public class CyclicBarrierDemo {


    public static void main(String[] args) {
        test();
    }
    public static void test() {

        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()-> {
            System.out.println("召唤神龙成功!");
        });
        for (int i = 1; i <=7 ; i++) {
            final int temp = i;
            // lambda能操作到 i 吗
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"个龙珠");
                try {
                    cyclicBarrier.await(); // 等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore

Semaphore(信号量)是用来控制同时访问特定资源的线程数量,它通过协调各个线程,以保证合理的使用公共资源。很多年以来,我都觉得从字面上很难理解Semaphore所表达的含义,只能把它比作是控制流量的红绿灯,比如XX马路要限制流量,只允许同时有一百辆车在这条路上行使,其他的都必须在路口等待,所以前一百辆车会看到绿灯,可以开进这条马路,后面的车会看到红灯,不能驶入XX马路,但是如果前一百辆中有五辆车已经离开了XX马路,那么后面就允许有5辆车驶入马路,这个例子里说的车就是线程,驶入马路就表示线程在执行,离开马路就表示线程执行完成,看见红灯就表示线程被阻塞,不能执行。

Semaphore 类中比较重要的几个方法:

  1. public void acquire(): 用来获取一个许可,若无许可能够获得,则会一直等待,直到获得许
    可。
  2. public void acquire(int permits):获取 permits 个许可
  3. public void release() { } :释放许可。注意,在释放许可之前,必须先获获得许可。
  4. public void release(int permits) { }:释放 permits 个许可
    上面 4 个方法都会被阻塞,如果想立即得到执行结果,可以使用下面几个方法13/04/2018 Page 86 of 283
  5. public boolean tryAcquire():尝试获取一个许可,若获取成功,则立即返回 true,若获取失
    败,则立即返回 false
  6. public boolean tryAcquire(long timeout, TimeUnit unit):尝试获取一个许可,若在指定的
    时间内获取成功,则立即返回 true,否则则立即返回 false
  7. public boolean tryAcquire(int permits):尝试获取 permits 个许可,若获取成功,则立即返
    回 true,若获取失败,则立即返回 false
  8. public boolean tryAcquire(int permits, long timeout, TimeUnit unit): 尝试获取 permits
    个许可,若在指定的时间内获取成功,则立即返回 true,否则则立即返回 false
  9. 还可以通过 availablePermits()方法得到可用的许可数目。

应用场景

Semaphore可以用于做流量控制,特别公用资源有限的应用场景;

public class SemaphoreDemo {
    public static void main(String[] args) {
        // 线程数量:停车位! 限流!
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <=6 ; i++) {
            new Thread(()->{
                try {
                 		 // acquire() 得到
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                            TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); // release() 释放
                }
            },String.valueOf(i)).start();
        }
    }
}

预告:下一篇会分析一下AQS的实现原理,因为CountDownLatch、CyclicBarrier、Semaphore都是基于AQS实现的;

参考

JDK 7 中的 Fork/Join 模式
一文秒懂 Java Fork/Join
并发工具类(三)控制并发线程数的Semaphore


你的鼓励也是我创作的动力

打赏地址

你可能感兴趣的:(后端,多线程&多进程)