【小家java】Java定时任务ScheduledThreadPoolExecutor详解以及与Timer、TimerTask的区别（执行指定次数停止任务）

public class Timer {}
// TimerTask 是个抽象类
public abstract class TimerTask implements Runnable {}

public static void main(String[] args) throws ParseException {
        Timer timer = new Timer();
        //1、设定两秒后执行任务
        //timer.scheduleAtFixedRate(new MyTimerTask1(), 2000,1000);
        //2、设定任务在执行时间执行，本例设定时间13:57:00
        SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        Date time = dateFormatter.parse("2018/11/04 18:40:00");
        //让在指定的时刻执行（如果是过去时间会立马执行 如果是将来时间 那就等吧）
        timer.schedule(new MyTimerTask1(), time);
    }

    //被执行的任务必须继承TimerTask，并且实现run方法
    static class MyTimerTask1 extends TimerTask {
        public void run() {
            System.out.println("爆炸！！！");
        }
    }

/**
 * 定时器
 *
 * @author fangshixiang
 * @description //
 * @date 2019/1/22 17:55
 */
public class TaskTest {

    /**
     * 需求描述：满足条件后启动一个定时任务，再满足另外一个条件后停止此定时任务
     * （阶段性定时任务）
     * 备注：若单线程就能搞定，就使用timer即可，若需要多线程环境，请使用JDK5提供的ScheduledThreadPoolExecutor
     */
    public static void main(String[] args) {
        Timer timer = new Timer();

        // 三秒后开始执行任务，每隔2秒执行一次  当执行的总次数达到10此时，停止执行
        timer.schedule(new Task(timer, 10), 3 * 1000, 2000);
    }
}

class Task extends TimerTask {
    private Timer timer;
    private int exeCount; //此处没有线程安全问题

    public Task(Timer timer, int exeCount) {
        this.timer = timer;
        this.exeCount = exeCount;
    }

    private int i = 1;

    @Override
    public void run() {
        System.out.println("第" + i++ + "次执行任务");

        //处理业务逻辑start...
        //处理业务逻辑end...

        //若满足此条件 退出此线程
        if (i > exeCount) {
            this.timer.cancel();
            System.out.println("#### timer任务程序结束 ####");
        }
    }
}

第1次执行任务
第2次执行任务
第3次执行任务
第4次执行任务
第5次执行任务
第6次执行任务
第7次执行任务
第8次执行任务
第9次执行任务
第10次执行任务
#### timer任务程序结束 ####

ScheduledThreadPoolExecutor(int corePoolSize) //使用给定核心池大小创建一个新定定时线程池 
ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactorythreadFactory) //使用给定的初始参数创建一个新对象，可提供线程创建工厂

    private final static ScheduledThreadPoolExecutor schedual = new ScheduledThreadPoolExecutor(1, new ThreadFactory() {
        private AtomicInteger atoInteger = new AtomicInteger(0);

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setName("xxx-Thread " + atoInteger.getAndIncrement());
            return t;
        }
    });

// 执行一次
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);

// 周期性执行
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                 long initialDelay, long delay, TimeUnit unit);
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay, long period, TimeUnit unit);

public class ScheduledThreadPoolExecutorTest {
  private ScheduledThreadPoolExecutor executor;
  private Runnable task;
  
  @Before
  public void before() {
    executor = initExecutor();
    task = initTask();
  }
  
  private ScheduledThreadPoolExecutor initExecutor() {
    return new ScheduledThreadPoolExecutor(2);;
  }
  
  private Runnable initTask() {
    long start = System.currentTimeMillis();
    return () -> {
      print("start task: " + getPeriod(start, System.currentTimeMillis()));
      sleep(SECONDS, 10);
      print("end task: " + getPeriod(start, System.currentTimeMillis()));
    };
  }
  
  @Test
  public void testFixedTask() {
    print("start main thread");
    executor.scheduleAtFixedRate(task, 15, 30, SECONDS);
    sleep(SECONDS, 120);
    print("end main thread");
  }
  
  @Test
  public void testDelayedTask() {
    print("start main thread");
    executor.scheduleWithFixedDelay(task, 15, 30, SECONDS);
    sleep(SECONDS, 120);
    print("end main thread");
  }

  private void sleep(TimeUnit unit, long time) {
    try {
      unit.sleep(time);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

  private int getPeriod(long start, long end) {
    return (int)(end - start) / 1000;
  }

  private void print(String msg) {
    System.out.println(msg);
  }
}
第一个输出：
start main thread
start task: 15
end task: 25
start task: 45
end task: 55
start task: 75
end task: 85
start task: 105
end task: 115
end main thread
第二个输出：
start main thread
start task: 15
end task: 25
start task: 55
end task: 65
start task: 95
end task: 105
end main thread