线程池(三)-java内置线程池 ScheduledExecutorService

一、ScheduledExecutorService 接口中的方法

• <V> ScheduledFuture<V> schedule(Callable<V> callable,long delay, TimeUnit unit)：延迟时间单位是unit，数量 delay 的时间后执行callable

• ScheduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit):延迟时间单位是unit，数量 delay 的时间后执行 command

• ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit):延迟时间单位是unit，数量是initialDelay的时间后，每隔period时间执行命令重复执行一次 (initialDelay秒后开始执行，之后每period秒循环执行一次，若上一个线程执行时间超过period秒，则需等上一个线程执行完毕后才能执行；若上一个线程执行时间不超过period秒，则每隔period时间执行命令重复执行一次)

• ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit)：创建并执行在一个任务在给定延迟首次启动这名(initialDelay秒后开始执行，等上一个线程执行完毕后需延迟delay秒再执行)

二、获取 ScheduledExecutorService

• static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)：创建一个可重用固定线程数的线程池且允许延迟运行或定期执行任务

• static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)：创建一个可重用固定线程数的线程池且线程中的所有线程都是用ThreadFactory来创建，且允许延迟运行或定期执行

• static ScheduledExecutorService newSingleThreadScheduledExecutor()：创建一个单线程执行程序，允许在给定延迟后运行命令或者定期地执行

• static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)：创建一个单线程执行程序，可安排在给定延迟后运行或定期地执行

三、使用案例

创建任务类

public class MyThread implements Runnable{
	//线程ID
    private int id;

    public MyThread(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        System.out.println("执行了："+Thread.currentThread().getName()+",编号："+id);
        try {
            Thread.sleep(20000);
            System.out.println("睡眠结束。。");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

1、通过 newSingleThreadExecutor 获取 ScheduledExecutorService

public class UseNewSingleThreadExecutor {
    public static void main(String[] args) {
        test1();
    }

    public static void test1(){
        ExecutorService es = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            es.submit(new MyThread(i));
        }
    }
    
	/**
     * 自定义线程
     */
    public static void test2(){
        ExecutorService es = Executors.newSingleThreadExecutor(new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r);
            }
        });
        for (int i = 0; i < 10; i++) {
            es.submit(new MyThread(i));
        }
    }
}

2、通过 newScheduledThreadPool 获取 ScheduledExecutorService

public class UseNewScheduledThreadPool {
    public static void main(String[] args) {
        test2();
    }

    public static void test1(){
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        for (int i = 0; i < 10; i++) {
            scheduledExecutorService.schedule(new MyThread(i), 10, TimeUnit.SECONDS);
        }
    }
	
	/**
     * 自定义线程
     */
    public static void test2(){
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3, new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r);
            }
        });
        //5秒后开始执行，之后每10秒循环执行一次，若执行时间超过10秒，则需等上一个线程执行完毕后才能执行
//        scheduledExecutorService.scheduleAtFixedRate(new MyThread(1), 5,10, TimeUnit.SECONDS);
        //5秒后开始执行，等上一个线程执行完毕后需延迟2秒再执行
        scheduledExecutorService.scheduleWithFixedDelay(new MyThread(1), 5,10, TimeUnit.SECONDS);
    }
}