java线程执行器框架介绍（二）--ScheduledThreadPoolExecutor

在java多线程操作中，我们有时需要延时或才周期性的执行某些执行，这时我们可以使用ScheduledThreadPoolExecutor。

一、工厂类Executors生成的ScheduledThreadPoolExecutor

1、newSingleThreadScheduledExecutor，单个线程

2、newSingleThreadScheduledExecutor，指定线程

二、常用方法

1、schedule，延迟指定时间，再执行线程；

2、scheduleAtFixedRateMethod，以固定的频率，执行线程；

3、scheduleWithFixedDelayMethod，以固定的延迟，执行线程；

其中scheduleAtFixedRateMethod和scheduleWithFixedDelayMethod的区别需要注意下，

scheduleAtFixedRateMethod是指以固定的频率执行，也就是说只有线程有空闲且按固定频率到了时间点，则执行；

scheduleWithFixedDelayMethod是指以固定的延迟，执行线程，也就是前一次执行完后，再以固定的延迟执行，执行时间点与任务执行时间有关。

三、实例

public class ScheduledThreadPoolExecutorMain {
    public static void main(String[] args)throws Exception {
        scheduelMethod();  //scheduelMethod方法
        scheduleAtFixedRateMethod(); //scheduleAtFixed/RateMethod方法
        scheduleWithFixedDelayMethod(); //scheduleWithFixedDelayMethod方法
    }

    static void scheduelMethod() throws Exception {
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        System.out.println("scheduelMethod start : "+ new Date());
        Future<Integer> resultFuture = executor.schedule(new Payer1(),3,TimeUnit.SECONDS);
        Integer result = resultFuture.get();

        System.out.println("scheduelMethod get result : "+result);
        executor.shutdown();
    }

    static void scheduleAtFixedRateMethod() throws Exception {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);
        System.out.println("scheduleAtFixedRateMethod start : "+ new Date());
        executor.scheduleAtFixedRate(new Payer(),3,2,TimeUnit.SECONDS);

        TimeUnit.SECONDS.sleep(10);
        executor.shutdown();
    }

    static void scheduleWithFixedDelayMethod() throws Exception {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);
        System.out.println("scheduleAtFixedRateMethod start : "+ new Date());
        executor.scheduleWithFixedDelay(new Payer(),3,2,TimeUnit.SECONDS);

        TimeUnit.SECONDS.sleep(10);
        executor.shutdown();
    }

    static class Payer implements Runnable{

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+" payer  start : "+ new Date());
            try {
                TimeUnit.SECONDS.sleep((long) (Math.random()*3));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" pay 1" + "   end :"+new Date());
        }
    }

    static class Payer1 implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {
            System.out.println(Thread.currentThread().getName()+" payer1  start : "+ new Date());
            int result = 1;
            System.out.println(Thread.currentThread().getName()+" payer1 return result: "+result);
            return result;
        }
    }
}

运行结果：

scheduelMethod start : Fri Jun 09 23:53:37 CST 2017
pool-1-thread-1 payer1  start : Fri Jun 09 23:53:40 CST 2017
pool-1-thread-1 payer1 return result: 1
scheduelMethod get result : 1
scheduleAtFixedRateMethod start : Fri Jun 09 23:53:40 CST 2017
pool-2-thread-1 payer  start : Fri Jun 09 23:53:43 CST 2017
pool-2-thread-1 pay 1   end :Fri Jun 09 23:53:44 CST 2017
pool-2-thread-1 payer  start : Fri Jun 09 23:53:45 CST 2017
pool-2-thread-1 pay 1   end :Fri Jun 09 23:53:45 CST 2017
pool-2-thread-2 payer  start : Fri Jun 09 23:53:47 CST 2017
pool-2-thread-2 pay 1   end :Fri Jun 09 23:53:47 CST 2017
pool-2-thread-1 payer  start : Fri Jun 09 23:53:49 CST 2017
scheduleAtFixedRateMethod start : Fri Jun 09 23:53:50 CST 2017
pool-2-thread-1 pay 1   end :Fri Jun 09 23:53:50 CST 2017
pool-3-thread-1 payer  start : Fri Jun 09 23:53:53 CST 2017
pool-3-thread-1 pay 1   end :Fri Jun 09 23:53:55 CST 2017
pool-3-thread-1 payer  start : Fri Jun 09 23:53:57 CST 2017
pool-3-thread-1 pay 1   end :Fri Jun 09 23:53:57 CST 2017
pool-3-thread-2 payer  start : Fri Jun 09 23:53:59 CST 2017
pool-3-thread-2 pay 1   end :Fri Jun 09 23:54:00 CST 2017