线程串行并行调度实现

线程串行并行调度实现

问题描述

问题描述：线程A、B、C并行执行，然后和线程D串行执行，如何实现。

问题具体化：现在有A、B、C三个线程，每一个线程分别完成打印0～4的任务，有一个线程D，在A、B、C完成打印之后打印“Hello world!”。

解决思路

我们都知道线程就是用来实现并发执行的，而要实现的结果是在A、B、C三个线程并行执行完之后才执行线程D的任务，那么就需要获取等到A、B、C三个线程的结果，之后再调用线程D的执行方法，就需要想办法让线程D暂不执行，等待A、B、C三个线程执行完才执行，根据这个思路，我们可以想到的解决方案方法如下：

• 通过一些flag变量控制判断A、B、C三个线程是否执行完

这是一个理解起来最简单也是最原始的方法，通过不断循环判断A、B、C三个线程对应的标识符是否完成执行来决定是否该执行线程D。

• 在线程D执行前阻塞线程，等待A、B、C三个线程执行完在执行

这个思路和上面差不多，只不过一个是循环判断，一个是阻塞线程。阻塞线程的方法有很多，sleep了，上锁了之类的，但是我们除了阻塞线程外，还需要有一个时机去唤醒阻塞，这个时机的触发点就是A、B、C三个线程执行完，综合考虑，能满足这样条件的阻塞方式有以下几种：

1、thread.join() 阻塞等待当前线程执行完

2、利用FeatureTask实现的线程，通过get（）方法可以阻塞等待线程结果返回

3、CountDownLatch，通过闭锁计数器的方式，通过await方法阻塞线程，在A、B、C三个线程执行完之后减少计数，唤醒阻塞

4、CyclicBarrier，栅栏原理，通过其await方法阻塞线程，在A、B、C三个线程执行完之后触发到达栅栏数，唤醒阻塞

以上就是能想到的实现方式，接下来一个一个用代码的方式实现并简要介绍其原理和特性。

解决方案及原理分析

通过flag变量控制

• 代码实现

//线程类
class MyRunnable implements Runnable {
   
    Flag flag;//变量
    CountDownLatch countDownLatch;//闭锁
    CyclicBarrier cyclicBarrier;//栅栏

    /**
     * 变量控制的方法
     *
     * @param flag
     */
    public MyRunnable(Flag flag) {
   
        this.flag = flag;
    }

    /**
     * 通过其他阻塞的方法时调用
     */
    public MyRunnable() {
   

    }
  	/**
     * 通过CountDownLatch的方式
     */
    public MyRunnable(CountDownLatch countDownLatch) {
   
        this.countDownLatch = countDownLatch;
    }
    /**
     * 通过CyclicBarrier的方式
     */
    public MyRunnable(CyclicBarrier cyclicBarrier) {
   
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
    public void run() {
   
        for (int i = 0; i < 5; i++) {
   
            try {
   
                Thread.sleep(new Random().nextInt(100));
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            System.out.println("当前线程：" + Thread.currentThread().getName() + " >> " + i);
        }
        if (countDownLatch != null) {
   //通过闭锁方式
            countDownLatch.countDown();
        }
        if (cyclicBarrier != null) {
   //通过栅栏方式
            try {
   
                cyclicBarrier.await();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
   
                e.printStackTrace();
            }
        }
        if (flag != null) {
   //通过flag变量方式
            flag.setFlag(true);
            System.out.println("当前线程：" + Thread.currentThread().getName() + " >> " + flag.isFlag());
        }
    }
}

class Flag {
   
    boolean flag = false;

    public void setFlag(boolean flag) {
   
        this.flag = flag;
    }

    public boolean isFlag() {
   
        return flag;
    }
}

/**
 * 线程调度方法1 flag变量控制
 * Created by anonyper on 2019/10/17.
 */
public class ThreadTest {
   
    Flag flagA = new Flag();//考虑一下这里为什么用一个对象包装一个boolean而不是直接用boolean对象来传递呢
    Flag flagB = new Flag();
    Flag flagC = new Flag();

    public void testThread() {
   
        Thread threadA = new Thread(new MyRunnable(flagA), "A");
        Thread threadB = new Thread(new MyRunnable(flagB), "B");
        Thread threadC = new Thread(new MyRunnable(flagC), "C");
        Thread threadD = new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                System.out.println("当前线程：" + Thread.currentThread().getName() + " >> Hello World!");
            }
        }, "D");
        threadA.start();
        threadB.start();
        threadC.start();
        while (!flagA.isFlag() || !flagB.isFlag() || !flagC.isFlag()) {
   
            Thread.yield();//释放CPU资源
          	//this.wait(0L); //这样也可以等待 释放CPU资源
          	//sleep(0L);//这样也可以等待 释放CPU资源
        }
        threadD.start();
    }

    public static void main(St