Java的ScheduledExecutorService任务调度使用(延时，定时执行)

package uu;

import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 任务调度工具类
 * 
 * @author linxu
 * @date 2020/07/18
 *
 */
public class ExecutorUtil {
    public static final ScheduledExecutorService COMMON_LOGIC_EXECUTOR = Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors() * 2, new ThreadFactory() {
                AtomicInteger count = new AtomicInteger(0);
                @Override
                public Thread newThread(Runnable r) {
                    int curCount = count.incrementAndGet();
                    System.err.println("任务调度线程池"+curCount);
                    return new Thread(r, "任务调度线程池" + curCount);
                }
            });

    public static ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period) {
        return COMMON_LOGIC_EXECUTOR.scheduleAtFixedRate(command, initialDelay, period, TimeUnit.MILLISECONDS);
    }

    public static ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period,
            TimeUnit unit) {
        return COMMON_LOGIC_EXECUTOR.scheduleAtFixedRate(command, initialDelay, period, unit);
    }

    public static ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long period,
            TimeUnit unit) {
        return COMMON_LOGIC_EXECUTOR.scheduleWithFixedDelay(command, initialDelay, period, unit);
    }
    //延时执行，不重复
    public static ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
        return COMMON_LOGIC_EXECUTOR.schedule(command, delay, unit);
    }

    public static Future<?> submit(Runnable task) {
        return COMMON_LOGIC_EXECUTOR.submit(task);
    }

    // 优雅的关闭线程池
    public static void close() {
        COMMON_LOGIC_EXECUTOR.shutdown();
        try {
            // // 等待未完成任务结束
            System.err.println("等待未完成任务结束");
            if (!COMMON_LOGIC_EXECUTOR.awaitTermination(60, TimeUnit.SECONDS)) {
                COMMON_LOGIC_EXECUTOR.shutdown();
            }
            // // 等待任务取消的响应
            System.err.println("等待任务取消的响应");
            if (!COMMON_LOGIC_EXECUTOR.awaitTermination(60, TimeUnit.SECONDS)) {

            }
        } catch (Exception e) {
            COMMON_LOGIC_EXECUTOR.shutdown();
            // 保留中断状态
            System.err.println("保留中断状态");
            Thread.currentThread().interrupt();
        }
    }
    
    
    
    
    
    
    public static void main(String[] args) throws Exception {
        System.err.println("jvm空闲内存："+Runtime.getRuntime().freeMemory());
        System.err.println("jvm最大内存："+Runtime.getRuntime().maxMemory());
        System.err.println("jvm总内存："+Runtime.getRuntime().totalMemory());
        final ScheduledFuture<?> scheduledFuture = schedule(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.err.println("sdmnclksdklds1");
            }
        }, 3000, TimeUnit.MILLISECONDS);

        schedule(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.err.println("sdmnclksdklds2");
            }
        }, 1000, TimeUnit.MILLISECONDS);
        
        
        
        new Thread() {
            public void run() {
                try {
                    Thread.sleep(1000);
                    System.err.println("是否完成："+scheduledFuture.isDone());
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }.start();

        new Thread() {

            public void run() {
                try {
                    
                    Thread.sleep(5000);
                    System.err.println("是否完成："+scheduledFuture.isDone());
                    close();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }.start();
    }

}