public interface ExecutorService extend Executor{
}

public interface Executor {
  void execute(Runnable command);
}

public class Executors {
//newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
}
//newCacheThreadPool
 public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());
  }
 //newScheduledThreadPool
  public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
  }
  //newStringooo
}

package thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;

/**
 * Created by yang on 16-7-11.
 */
public class Ch09_Executor {
  private static void run(ExecutorService threadPool) {
    for (int i = 1; i < 5; i++) {
      final int taskID=i;
      threadPool.execute(new Runnable() {
        @Override
        public void run() {
          for(int i=1;i<5;i++){
            try{
              Thread.sleep(20);
            }catch (InterruptedException e)
            {
              e.printStackTrace();
            }
            System.out.println("第"+taskID+"次任务的第"+i+"次执行");
          }
        }
      });
    }
    threadPool.shutdown();

  }

  public static void main(String[] args) {
    //创建可以容纳3个线程的线程池
    ExecutorService fixedThreadPool= Executors.newFixedThreadPool(3);
    //线程池的大小会根据执行的任务动态的分配
    ExecutorService cacheThreadPool=Executors.newCachedThreadPool();
    //创建单个线程的线程池,如果当前线程在执行任务时突然中断,则会创建一个新的线程替换它继续执行.
    ExecutorService singleThreadPool=Executors.newSingleThreadExecutor();
    //效果类似于Timer定时器
    ScheduledExecutorService scheduledThreadPool=Executors.newScheduledThreadPool(3);
    // run(fixedThreadPool); //(1)
    //run(cacheThreadPool); //(2)
    // run(singleThreadPool); //(3)
    // run(scheduledThreadPool); //(4)
  }
}

第1次任务的第1次执行
第3次任务的第1次执行
第2次任务的第1次执行
第4次任务的第1次执行
第3次任务的第2次执行
第1次任务的第2次执行
第2次任务的第2次执行
第4次任务的第2次执行
第3次任务的第3次执行
第1次任务的第3次执行
第2次任务的第3次执行
第4次任务的第3次执行
第3次任务的第4次执行
第2次任务的第4次执行
第4次任务的第4次执行
第1次任务的第4次执行

第1次任务的第1次执行
第3次任务的第1次执行
第2次任务的第1次执行
第1次任务的第2次执行
第3次任务的第2次执行
第2次任务的第2次执行
第1次任务的第3次执行
第3次任务的第3次执行
第2次任务的第3次执行
第1次任务的第4次执行
第3次任务的第4次执行
第2次任务的第4次执行
第4次任务的第1次执行
第4次任务的第2次执行
第4次任务的第3次执行
第4次任务的第4次执行

第1次任务的第1次执行
第1次任务的第2次执行
第1次任务的第3次执行
第1次任务的第4次执行
第2次任务的第1次执行
第2次任务的第2次执行
第2次任务的第3次执行
第2次任务的第4次执行
第3次任务的第1次执行
第3次任务的第2次执行
第3次任务的第3次执行
第3次任务的第4次执行
第4次任务的第1次执行
第4次任务的第2次执行
第4次任务的第3次执行
第4次任务的第4次执行

package thread;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * Created by yang on 16-7-11.
 */
public class MyScheduledTask implements Runnable {
  private String tname;
  public MyScheduledTask(String name){
    this.tname=name;
  }
  public void run(){
    System.out.println(tname+"任务时延时2秒执行!");
  }

  public static void main(String[] args) {
    ScheduledExecutorService scheduledPool= Executors.newScheduledThreadPool(2);
    ScheduledExecutorService singSchedulePool=Executors.newSingleThreadScheduledExecutor();
    MyScheduledTask mt1=new MyScheduledTask("mt1");
    MyScheduledTask mt2=new MyScheduledTask("mt2");
    //以scheduledThreadPool启动mt1任务执行
    scheduledPool.schedule(mt1,2, TimeUnit.SECONDS);
    //用singlescheduledthreadPool启动mt2;
    singSchedulePool.schedule(mt2,2000,TimeUnit.MILLISECONDS);
    scheduledPool.shutdown();
    singSchedulePool.shutdown();
  }
}

mt1任务时延时2秒执行!
mt2任务时延时2秒执行!