定时任务（等待结果）

背景

业务需求：	主线程定时轮询某个任务是否结束、
			结束获取任务的结果，进行下一步处理，
			未结束则主线程阻塞，等待任务结束

实现

1、定义一个定时任务

import java.util.concurrent.Executors;  
import java.util.concurrent.ScheduledExecutorService;  
import java.util.concurrent.TimeUnit;  
  
public class ScheduledTask {  
    private boolean canceled = false;  
    
   	public boolean isCanceled() {
        return canceled;
    }
    
    public void scheduleTask() {  
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);  
        executor.scheduleAtFixedRate(new Runnable() {  
            @Override  
            public void run() {  
                if (!canceled) {  
                    // 获取任务状态并进行判断  
                    if (isTaskRunning()) {  
                        // 任务正在运行，进行相应的处理  
                    } else {  
                        // 任务未运行，取消定时任务  
                        canceled = true;  
                        executor.shutdown();  
                    }  
                }  
            }  
        }, 0, 10, TimeUnit.SECONDS); // 每10秒执行一次  
    }  
  
    private boolean isTaskRunning() {  
        // 判断任务是否正在运行，返回true或false  
        return false;  
    }  
}

2、主线程通过无限循环、获取定时状态

 				RateSchedule schedule = new RateSchedule();
 				//开启定时任务
                schedule.scheduleTask();
                while (true) {
                    //循环直到任务完成
                    if (schedule.isCanceled()) break;
                }

关于阻塞主线程

本次使用的是while true无限循环的方式、后面查询资料发现另一种方式作为拓展
使用 CountDownLatch 阻塞主线程，下面为示例

public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        CountDownLatch latch = new CountDownLatch(1);//初始化latch 为1
        AtomicBoolean canceled = new AtomicBoolean(false);
        AtomicInteger i = new AtomicInteger(0);
        executor.scheduleAtFixedRate(() -> {
            if (!canceled.get()) {
                // 任务未运行，取消定时任务
                System.out.println("子线程" + Thread.currentThread().getName() + "执行中...");
                i.getAndIncrement();
                if (3 == i.get()) {
                    latch.countDown(); //latch 自减、为0时线程不阻塞
                    canceled.set(true);
                    executor.shutdown();
                }
            }
        }, 0, 5, TimeUnit.SECONDS); // 每5秒执行一次

        try {
            System.out.println("主线程" + Thread.currentThread().getName() + "等待子线程执行完成...");
            latch.await();//阻塞当前线程，直到计数器的值为0
            System.out.println("主线程" + Thread.currentThread().getName() + "开始执行...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

打野结果如下

主线程main等待子线程执行完成...
子线程pool-1-thread-1执行中...
子线程pool-1-thread-1执行中...
子线程pool-1-thread-1执行中...
主线程main开始执行...

Process finished with exit code 0