public static ExecutorService newFixedThreadPool(int nThreads) {
 return new ThreadPoolExecutor(nThreads, nThreads,
     0L, TimeUnit.MILLISECONDS,
     new LinkedBlockingQueue<Runnable>());
}


public static ExecutorService newSingleThreadExecutor() {
 return new FinalizableDelegatedExecutorService
  (new ThreadPoolExecutor(1, 1,
     0L, TimeUnit.MILLISECONDS,
     new LinkedBlockingQueue<Runnable>()));
}


public static ExecutorService newCachedThreadPool() {
 return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
     60L, TimeUnit.SECONDS,
     new SynchronousQueue<Runnable>());
}

public ThreadPoolExecutor(int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue) {
 this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
  Executors.defaultThreadFactory(), defaultHandler);
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo {
 public static class MyTask implements Runnable {
 @Override
 public void run() {
 System.out.println(System.currentTimeMillis() + "Thread ID:"
 + Thread.currentThread().getId());
 try {
 Thread.sleep(1000);
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 }

 public static void main(String[] args) {
 MyTask myTask = new MyTask();
 ExecutorService es = Executors.newFixedThreadPool(5);
 for (int i = 0; i < 10; i++) {
 es.submit(myTask);
 }
 }
}

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


public class ThreadPoolDemo {
 public static void main(String[] args) {
 ScheduledExecutorService ses = Executors.newScheduledThreadPool(10);
 //如果前面的任务还未完成，则调度不会启动。
 ses.scheduleWithFixedDelay(new Runnable() {
 
 @Override
 public void run() {
 try {
 Thread.sleep(1000);
 System.out.println(System.currentTimeMillis()/1000);
 } catch (Exception e) {
 // TODO: handle exception
 }
 
 }
 }, 0, 2, TimeUnit.SECONDS);//启动0秒后执行，然后周期2秒执行一次
 }
}

ExecutorService es = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.SECONDS,
 new LinkedBlockingQueue<Runnable>()){

 @Override
 protected void beforeExecute(Thread t, Runnable r) {
 System.out.println("准备执行");
 }

 @Override
 protected void afterExecute(Runnable r, Throwable t) {
 System.out.println("执行完成");
 }

 @Override
 protected void terminated() {
 System.out.println("线程池退出");
 }
 
 };

public ThreadPoolExecutor(int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory,
    RejectedExecutionHandler handler) {
 if (corePoolSize < 0 ||
  maximumPoolSize <= 0 ||
  maximumPoolSize < corePoolSize ||
  keepAliveTime < 0)
  throw new IllegalArgumentException();
 if (workQueue == null || threadFactory == null || handler == null)
  throw new NullPointerException();
 this.corePoolSize = corePoolSize;
 this.maximumPoolSize = maximumPoolSize;
 this.workQueue = workQueue;
 this.keepAliveTime = unit.toNanos(keepAliveTime);
 this.threadFactory = threadFactory;
 this.handler = handler;
 }

ExecutorService es = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.SECONDS,
 new LinkedBlockingQueue<Runnable>(),
 new RejectedExecutionHandler() {

 @Override
 public void rejectedExecution(Runnable r,
 ThreadPoolExecutor executor) {
 System.out.println(r.toString() + "is discard");
 }
 });

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;

 DefaultThreadFactory() {
  SecurityManager s = System.getSecurityManager();
  group = (s != null) ? s.getThreadGroup() :
     Thread.currentThread().getThreadGroup();
  namePrefix = "pool-" +
    poolNumber.getAndIncrement() +
    "-thread-";
 }

 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.ArrayList;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;


public class CountTask extends RecursiveTask<Long>{

 private static final int THRESHOLD = 10000;
 private long start;
 private long end;
 
 public CountTask(long start, long end) {
 super();
 this.start = start;
 this.end = end;
 }

 @Override
 protected Long compute() {
 long sum = 0;
 boolean canCompute = (end - start) < THRESHOLD;
 if(canCompute)
 {
 for (long i = start; i <= end; i++) {
 sum = sum + i;
 }
 }else
 {
 //分成100个小任务
 long step = (start + end)/100;
 ArrayList<CountTask> subTasks = new ArrayList<CountTask>();
 long pos = start;
 for (int i = 0; i < 100; i++) {
 long lastOne = pos + step;
 if(lastOne > end )
 {
 lastOne = end;
 }
 CountTask subTask = new CountTask(pos, lastOne);
 pos += step + 1;
 subTasks.add(subTask);
 subTask.fork();//把子任务推向线程池
 }
 for (CountTask t : subTasks) {
 sum += t.join();//等待所有子任务结束
 }
 }
 return sum;
 }
 
 public static void main(String[] args) {
 ForkJoinPool forkJoinPool = new ForkJoinPool();
 CountTask task = new CountTask(0, 200000L);
 ForkJoinTask<Long> result = forkJoinPool.submit(task);
 try {
 long res = result.get();
 System.out.println("sum = " + res);
 } catch (Exception e) {
 // TODO: handle exception
 e.printStackTrace();
 }
 }

}

final void runWorker(WorkQueue w) {
 w.growArray(); // allocate queue
 for (int r = w.hint; scan(w, r) == 0; ) {
  r ^= r << 13; r ^= r >>> 17; r ^= r << 5; // xorshift
 }
 }

private final int scan(WorkQueue w, int r) {
 WorkQueue[] ws; int m;
 long c = ctl;    // for consistency check
 if ((ws = workQueues) != null && (m = ws.length - 1) >= 0 && w != null) {
  for (int j = m + m + 1, ec = w.eventCount;;) {
  WorkQueue q; int b, e; ForkJoinTask<?>[] a; ForkJoinTask<?> t;
  if ((q = ws[(r - j) & m]) != null &&
   (b = q.base) - q.top < 0 && (a = q.array) != null) {
   long i = (((a.length - 1) & b) << ASHIFT) + ABASE;
   if ((t = ((ForkJoinTask<?>)
    U.getObjectVolatile(a, i))) != null) {
   if (ec < 0)
    helpRelease(c, ws, w, q, b);
   else if (q.base == b &&
     U.compareAndSwapObject(a, i, t, null)) {
    U.putOrderedInt(q, QBASE, b + 1);
    if ((b + 1) - q.top < 0)
    signalWork(ws, q);
    w.runTask(t);
   }
   }
   break;
  }
  else if (--j < 0) {
   if ((ec | (e = (int)c)) < 0) // inactive or terminating
   return awaitWork(w, c, ec);
   else if (ctl == c) {  // try to inactivate and enqueue
   long nc = (long)ec | ((c - AC_UNIT) & (AC_MASK|TC_MASK));
   w.nextWait = e;
   w.eventCount = ec | INT_SIGN;
   if (!U.compareAndSwapLong(this, CTL, c, nc))
    w.eventCount = ec; // back out
   }
   break;
  }
  }
 }
 return 0;
 }

final void runTask(ForkJoinTask<?> task) {
  if ((currentSteal = task) != null) {
  ForkJoinWorkerThread thread;
  task.doExec();
  ForkJoinTask<?>[] a = array;
  int md = mode;
  ++nsteals;
  currentSteal = null;
  if (md != 0)
   pollAndExecAll();
  else if (a != null) {
   int s, m = a.length - 1;
   ForkJoinTask<?> t;
   while ((s = top - 1) - base >= 0 &&
    (t = (ForkJoinTask<?>)U.getAndSetObject
    (a, ((m & s) << ASHIFT) + ABASE, null)) != null) {
   top = s;
   t.doExec();
   }
  }
  if ((thread = owner) != null) // no need to do in finally clause
   thread.afterTopLevelExec();
  }
 }

while ((s = top - 1) - base >= 0 && (t = (ForkJoinTask<?>)U.getAndSetObject(a, ((m & s) << ASHIFT) + ABASE, null)) != null)
{
 top = s;
 t.doExec();
}

else if (--j < 0) {
   if ((ec | (e = (int)c)) < 0) // inactive or terminating
   return awaitWork(w, c, ec);
   else if (ctl == c) {  // try to inactivate and enqueue
   long nc = (long)ec | ((c - AC_UNIT) & (AC_MASK|TC_MASK));
   w.nextWait = e;
   w.eventCount = ec | INT_SIGN;
   if (!U.compareAndSwapLong(this, CTL, c, nc))
    w.eventCount = ec; // back out
   }
   break;
  }