ScheduleExecutorService用法

java.util.concurrent包下有个ScheduleExecutorService接口，查看源码这个接口的作用主要是

An {@link ExecutorService} that can schedule commands to run after a given
 delay, or to execute periodically.


意思就是这个service可以录制一些命令在一段时间间隔之后执行，或者周期性的执行。
ScheduleExecutorService接口中有四个重要的方法，其中scheduleAtFixedRate和scheduleWithFixedDelay在实现定时程序时比较方便。

这两个方法定义如下：

/**
     * Creates and executes a periodic action that becomes enabled first
     * after the given initial delay, and subsequently with the given
     * period; that is executions will commence after
     * <tt>initialDelay</tt> then <tt>initialDelay+period</tt>, then
     * <tt>initialDelay + 2 * period</tt>, and so on.
     * If any execution of the task
     * encounters an exception, subsequent executions are suppressed.
     * Otherwise, the task will only terminate via cancellation or
     * termination of the executor.  If any execution of this task
     * takes longer than its period, then subsequent executions
     * may start late, but will not concurrently execute.
     *
     * @param command the task to execute
     * @param initialDelay the time to delay first execution
     * @param period the period between successive executions
     * @param unit the time unit of the initialDelay and period parameters
     * @return a ScheduledFuture representing pending completion of
     *         the task, and whose <tt>get()</tt> method will throw an
     *         exception upon cancellation
     * @throws RejectedExecutionException if the task cannot be
     *         scheduled for execution
     * @throws NullPointerException if command is null
     * @throws IllegalArgumentException if period less than or equal to zero
     */
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                          long initialDelay,
                          long period,
                          TimeUnit unit);

参数意义：
command：执行线程
initialDelay：初始化延时
period：两次开始执行最小间隔时间
unit：计时单位
    
    
    /**
         * Creates and executes a periodic action that becomes enabled first
         * after the given initial delay, and subsequently with the
         * given delay between the termination of one execution and the
         * commencement of the next.  If any execution of the task
         * encounters an exception, subsequent executions are suppressed.
         * Otherwise, the task will only terminate via cancellation or
         * termination of the executor.
         *
         * @param command the task to execute
         * @param initialDelay the time to delay first execution
         * @param delay the delay between the termination of one
         * execution and the commencement of the next
         * @param unit the time unit of the initialDelay and delay parameters
         * @return a ScheduledFuture representing pending completion of
         *         the task, and whose <tt>get()</tt> method will throw an
         *         exception upon cancellation
         * @throws RejectedExecutionException if the task cannot be
         *         scheduled for execution
         * @throws NullPointerException if command is null
         * @throws IllegalArgumentException if delay less than or equal to zero
         */
        public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                 long initialDelay,
                                 long delay,
                                 TimeUnit unit);

command：执行线程
initialDelay：初始化延时
period：前一次执行结束到下一次执行开始的间隔时间（间隔执行延迟时间）
unit：计时单位


    public class SystemClock {
    
        private static final SystemClock instance = new SystemClock();
    
        private final long precision;
        private final AtomicLong now;
        private ScheduledExecutorService scheduler;
    
        public static SystemClock getInstance() {
            return instance;
        }
    
        public SystemClock() {
            this(1L);
        }
    
        public SystemClock(long precision) {
            this.precision = precision;
            now = new AtomicLong(System.currentTimeMillis());
            scheduler = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
                @Override
                public Thread newThread(Runnable runnable) {
                    Thread thread = new Thread(runnable, "System_Clock");
                    thread.setDaemon(true);
                    return thread;
                }
            });
            scheduler.scheduleAtFixedRate(new Timer(now), precision, precision, TimeUnit.MILLISECONDS);
        }
    
        public long now() {
            return now.get();
        }
    
        public long precision() {
            return precision;
        }
    
        protected class Timer implements Runnable {
            // 注入进来，避免访问SystemClock.now占用很多CPU
            private final AtomicLong now;
    
            private Timer(AtomicLong now) {
                this.now = now;
            }
    
            @Override
            public void run() {
                now.set(System.currentTimeMillis());
            }
        }

上面这段程序是一个线程安全的时间辅助工具类，默认1毫秒会将系统时间和程序中的now进行同步。