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();
    }

}