多线程使用1

import java.util.TimerTask;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * <b>类描述：异步任务管理器</b>TODO<br/>
 * <b>@author：</b>hety<br/>
 * <b>版本信息：</b>version v1.0.0<br/>
 * <b>日期：</b>2018/12/18 10:00<br/>
 */
public class AsyncScheduleManager {

    /**
     * 线程池线程名称前缀
     */
    private final String THREAD_POOL_NAME_PREFIX = "AsyncTaskManager-";

    /**
     * 线程池默认核心线程数
     */
    private final int CORE_POOL_SIZE = 5;
    /**
     * 操作延迟1000毫秒
     */
    private final int OPERATE_DELAY_TIME = 3000;

    /**
     * 异步操作任务调度线程池
     */
    private ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(CORE_POOL_SIZE, new DefaultThreadFactory(THREAD_POOL_NAME_PREFIX));

    /**
     * 单例模式--饿汉方式，类装载时就实例化me
     */
    private static AsyncScheduleManager me = new AsyncScheduleManager();

    public static AsyncScheduleManager me() {
        return me;
    }

    /**
     * 延时执行任务
     * @param task TimerTask
     */
    public void schedule(TimerTask task)
    {
        executor.schedule(task, OPERATE_DELAY_TIME, TimeUnit.MILLISECONDS);
    }

    /**
     * 立即执行任务
     * @param task TimerTask
     */
    public void execute(TimerTask task)
    {
        executor.execute(task);
    }



    /**
     * The default thread factory
     */
    static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        /**
         * 构造器
         * @param threadName 线程名称前缀
         */
        DefaultThreadFactory(String threadName) {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                    Thread.currentThread().getThreadGroup();
            if (null == threadName || threadName.isEmpty()) {
                threadName = "pool";
            }
            namePrefix = threadName + poolNumber.getAndIncrement() + "-thread-";
        }

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                    namePrefix + threadNumber.getAndIncrement(),
                    0);
            if (t.isDaemon()) {
                t.setDaemon(false);
            }
            if (t.getPriority() != Thread.NORM_PRIORITY) {
                t.setPriority(Thread.NORM_PRIORITY);
            }
            return t;
        }
    }
}

import java.util.TimerTask;

/**
 * <b>类描述：</b>TODO<br/>
 * <b>@author：</b>hety<br/>
 * <b>版本信息：</b>version v1.0.0<br/>
 * <b>日期：</b>2018/12/18 11:34<br/>
 */
public class TaskFactory {

    public static TimerTask msg(Long msg) {
        return new TimerTask() {
            @Override
            public void run() {
                System.out.println(">>>>>>>>>msg:" + (System.currentTimeMillis() - msg)+"\t"+System.currentTimeMillis());
            }
        };
    }
}

测试

....

    public static void test002() throws ExecutionException, InterruptedException {
        AsyncScheduleManager.me().execute(TaskFactory.msg(System.currentTimeMillis()));
        AsyncScheduleManager.me().schedule(TaskFactory.msg(System.currentTimeMillis()));
    }