Java多线程 5.栅栏

1.Java多线程-认识Java线程

2.Java多线程-线程安全

3.Java多线程-线程协作

4.Java多线程-线程池

5.Java多线程-栅栏

6.Java多线程-Fork/Join

 

---

5.1 ReadMe

　　此文线程和任务可以理解为一个意思；

　　Java中一般通过CountDownLantch和CyclicBarrier来解决线程（任务）之间依赖的问题，栅栏特指CyclicBarrier类，因为CountDownLatch可以实现类似功能，所以在此放到一块讲解；

　　在任务A依赖任务B的这种场景可以使用Object的wait和notify来实现，但是如果任务A依赖任务B、C、D多个任务的场景，使用Object的wait和notify就难以实现，例如运动会10个人长跑（看作10个长跑任务），公布总排名这个任务就依赖至少9个长跑任务结束，这种场景适合使用CountDownLatch；

　　结合实际开发过程，更多的场景是A、B、C多个任务同时执行，但是A、B、C任务在执行过程中的某一个点相互依赖，例如一个需求分为前段开发和后端开发，前后端开始联调的时间点就是2个任务相互依赖的点，这种场景适合使用CyclicBarrier；

5.2 CountDownLatch

　　Latch是门闩的意思，要打开门需要打开门上的所有门闩，CountDownLatch可以理解为一个有多个门闩的门，每个门闩需要一个的线程打开；

　　代码实现举例：

import java.security.SecureRandom;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * CountDownLatch实例
 */
public class DemoCountDownLatch {

    //参赛人数 / 门闩个数
    private static final int COUNT_RUNNER = 3;

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

        // 3人参加比赛 / 创建一个有3个门闩的门
        CountDownLatch countDownLatch = new CountDownLatch(COUNT_RUNNER);

        // 创建3人跑道 / 装上门
        ExecutorService executorService = Executors.newFixedThreadPool(COUNT_RUNNER);

        for (int i = 0; i < 3; i++) {
            executorService.submit(new Runner("runner" + i, countDownLatch));
        }

        // 等待3人跑到终点 / 把3个门闩都锁上
        countDownLatch.await();

        // 公布3人成绩 / 打开门了
        System.out.println("all runner game over.");
    }

    static class Runner implements Runnable {

        private String name;

        private CountDownLatch countDownLatch;

        public Runner(String name, CountDownLatch countDownLatch) {
            this.name = name;
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            try {
                SecureRandom secureRandom = SecureRandom.getInstanceStrong();
                int runTime = Math.abs(secureRandom.nextInt()) % 10;
                TimeUnit.SECONDS.sleep(runTime);
                System.out.println(this.name + " game over cost " + runTime + " second.");
            } catch (Exception e) {
                e.printStackTrace();
            }

            // 跑到终点 / 打开门闩
            this.countDownLatch.countDown();
        }
    }
}

　 说明：

1. 一个CountDownLatch对象后只能使用一次，也就是说不能工作同一个CountDownLatch对象来重复控制线程的依赖问题;

2.上面的例子中如果有长跑运动员中途放弃比赛，是否永远不能公布总的比赛成绩？ CountDownLatch的await可以有入参（timeout, TimeUnit）表示最长等待时间;

5.3 CyclicBarrier

 CyclicBarrier是循环栅栏的的意思，循环表示同一个CyclicBarrier可以重复使用（区别于CountDownLatch），Barrier栅栏可以理解为线程相互依赖的那个点（例如前后端联调时间点），各个线程在那个点相互等待，等所有线程到达点后才继续执行；

代码实现举例：

import java.time.Instant;
import java.util.concurrent.*;

/**
 * 前端开发倩倩和后端开发厚厚开发一个需求
 * 两人先独自开发需求，等都开发完再一块联调功能
 */
public class DemoCyclicBarrier
{
    public static void main(String[] args) throws InterruptedException
    {

        // 创建栅栏，参数一为相互依赖的任务数；参数二为各任务到达依赖点后先执行的任务，等任务执行结束相互依赖的任务继续执行
        CyclicBarrier cyclicBarrier = new CyclicBarrier(2, () -> {
            System.out.println("准备开始联调吧...");
            lastSecond(3L);
        });

        // 创建线程池执行2个任务
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.execute(new Coder(10L, "后端", cyclicBarrier));
        executorService.execute(new Coder(3L, "前端", cyclicBarrier));
    }

    /**
     * 线程持续second秒
     */
    private static void lastSecond(long second)
    {
        Instant instant = Instant.now();
        while (Instant.now().minusSeconds(second).isBefore(instant))
        {
        }
    }

    static class Coder implements Runnable
    {
        // 完成工作需要的时间
        private long workTime;

        private String name;

        private CyclicBarrier cyclicBarrier;

        public Coder(long workTime, String name, CyclicBarrier cyclicBarrier)
        {
            this.workTime = workTime;
            this.name = name;
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run()
        {
            try
            {
                System.out.println(this.name + " are coding...");
                lastSecond(this.workTime);
                System.out.println(this.name + " code end wait debugging..");
                // 完成工作/到达依赖的点/我这边可以开始联调了
                this.cyclicBarrier.await();
                System.out.println("we are debugging..");

            }
            catch (InterruptedException e)
            {
                // 当前线程被中断
                e.printStackTrace();
            }
            catch (BrokenBarrierException e)
            {
                // 1.其他线程中断；2.其他线程await方法超时；3.cyclicBarrier重置
                e.printStackTrace();
            }
            // catch (TimeoutException e)
            // {
            // //当前线程的await方法超时(await方法设置超时参数)
            // e.printStackTrace();
            // }
        }
    }
}

说明：

1.CyclicBarrier作为循环栅栏，同一个对象可以循环使用；

2.上面例子中前端开发人员很短时间开发结束，通过await()一直在等待后端开发结束，可以通过await(timeout, TimeUnit)来设置最长等待时间；

3. 可以通过CyclicBarrier的getNumberWaiting()查看到达依赖点的任务；

4.CyclicBarrier构造方法的第二个参数指定的任务A，在其他相互依赖的任务到达依赖点后，任务A优先执行，并且是执行结束，其他任务才继续执行；

5.4 CyclicBarrier&CountDownLatch举例

import java.time.Instant;
import java.util.concurrent.*;

public class Demo_CyclicBarrier_CountDownLatch
{
    private static final int COUNT_WORKER = 2;

    public static void main(String[] args) throws InterruptedException
    {
        CountDownLatch countDownLatch = new CountDownLatch(COUNT_WORKER);
        CyclicBarrier cyclicBarrier = new CyclicBarrier(COUNT_WORKER, () -> {
            System.out.println("准备开始联调吧...");
            lastSecond(3L);
        });

        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.execute(new Coder(10L, "后端", countDownLatch, cyclicBarrier));
        executorService.execute(new Coder(3L, "前端", countDownLatch, cyclicBarrier));

        countDownLatch.await();
        System.out.println("开发联调结束，需求交付...");
    }

    /**
     * 线程持续second秒
     */
    private static void lastSecond(long second)
    {
        Instant instant = Instant.now();
        while (Instant.now().minusSeconds(second).isBefore(instant))
        {
        }
    }

    static class Coder implements Runnable
    {
        // 开发联调时间
        private long workTime;

        private String name;

        private CountDownLatch countDownLatch;

        private CyclicBarrier cyclicBarrier;

        public Coder(long workTime, String name, CountDownLatch countDownLatch, CyclicBarrier cyclicBarrier)
        {
            this.workTime = workTime;
            this.name = name;
            this.countDownLatch = countDownLatch;
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run()
        {
            try
            {
                System.out.println(this.name + " are coding...");
                lastSecond(this.workTime);
                System.out.println(this.name + " code end wait debugging..");

                this.cyclicBarrier.await();

                System.out.println(this.name + " are debugging..");
                lastSecond(this.workTime);

                System.out.println(this.name + " debug end..");
                this.countDownLatch.countDown();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}