Executors

构造函数

• newFixedThreadPool(int nThreads) ; 创建指定大小的线程池
• newSingleThreadExecutor()；创建一个只有一个线程的线程池
• newCachedThreadPool() ; 会根据需要创建线程，空闲的线程会被复用
• newScheduledThreadPool(int corePoolSize) ； 可定时任务，而且能周期运行

newScheduledThreadPool方法会返回ScheduledExecutorService

核心方法：

1. scheduleWithFixedDelay(Runnable command,long initialDelay, long period,TimeUnit unit)
2. scheduleAtFixedRate(Runnable command,long initialDelay, long period,TimeUnit unit)

initialDelay 设置任务延迟开始 ，period 为周期，则每隔多少秒运行一次

FixedDelay和FixedRate区别

FixedDelay 周期=任务执行时间+period

FixedRate 周期=（任务执行时间-period）+period

public static void main(String[] args) {
        MyTask myTask = new MyTask();
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);
//      scheduleWithFixedDelay
        ses.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                try {
                    Thread.sleep(8000);
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
                System.out.println(new Date());
            }
        }, 0, 2, TimeUnit.SECONDS);

    } 

自定义线程池

public class TraceThreadPoolExecutor extends ThreadPoolExecutor {



    public TraceThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
            BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }


    @Override
    public void execute(Runnable task) {
        super.execute(warp(task,clientTrace(),Thread.currentThread().getName()));
    }


    @Override
    public Future<?> submit(Runnable task) {
        return super.submit(warp(task,clientTrace(),Thread.currentThread().getName()));
    }

    private Exception clientTrace(){
        return new Exception("Client stack trace");

    }

    private Runnable warp(final Runnable task,final Exception clientStack,String ckientThradName){
        return new Runnable() {
            @Override
            public void run() {
                try {
                    task.run();
                } catch (Exception e) {
                    clientStack.printStackTrace();
                    throw e;

                }
            }
        };
    }

    static class Mytask implements  Runnable {
        int i,j;

        public Mytask(int i, int j) {
            super();
            this.i = i;
            this.j = j;
        }


        public void run() {
            double re=i/j;
            System.out.println(re);
        }
    }

    public static void main(String[] args) {
        TraceThreadPoolExecutor pool = new TraceThreadPoolExecutor(0, Integer.MAX_VALUE, 0l,
                TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        for (int i = 0; i <5; i++) {
            pool.execute(new Mytask(100, i));

        }

    }







}