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

 1     /**
 2      * Creates an Executor that uses a single worker thread operating
 3      * off an unbounded queue. (Note however that if this single
 4      * thread terminates due to a failure during execution prior to
 5      * shutdown, a new one will take its place if needed to execute
 6      * subsequent tasks.)  Tasks are guaranteed to execute
 7      * sequentially, and no more than one task will be active at any
 8      * given time. Unlike the otherwise equivalent
 9      * <tt>newFixedThreadPool(1)</tt> the returned executor is
10      * guaranteed not to be reconfigurable to use additional threads.
11      *
12      * @return the newly created single-threaded Executor
13      */
14     public static ExecutorService newSingleThreadExecutor() {
15         return new FinalizableDelegatedExecutorService
16             (new ThreadPoolExecutor(1, 1,
17                                     0L, TimeUnit.MILLISECONDS,
18                                     new LinkedBlockingQueue<Runnable>()));
19     }

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;public class Client {public static void main(String[] args) throws Exception {//创建单线程执行器ExecutorService es = Executors.newSingleThreadExecutor();//执行一个任务Future<String> future = es.submit(new Callable<String>() {public String call() throws Exception {return "";}});//获得任务执行后的返回值System.out.println("返回值：" + future.get());//关闭执行器
        es.shutdown();}
}

    /*** Creates a thread pool that creates new threads as needed, but* will reuse previously constructed threads when they are* available.  These pools will typically improve the performance* of programs that execute many short-lived asynchronous tasks.* Calls to <tt>execute</tt> will reuse previously constructed* threads if available. If no existing thread is available, a new* thread will be created and added to the pool. Threads that have* not been used for sixty seconds are terminated and removed from* the cache. Thus, a pool that remains idle for long enough will* not consume any resources. Note that pools with similar* properties but different details (for example, timeout parameters)* may be created using {@link ThreadPoolExecutor} constructors.** @return the newly created thread pool*/public static ExecutorService newCachedThreadPool() {return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());}

    /*** Creates a thread pool that reuses a fixed number of threads* operating off a shared unbounded queue.  At any point, at most* <tt>nThreads</tt> threads will be active processing tasks.* If additional tasks are submitted when all threads are active,* they will wait in the queue until a thread is available.* If any thread terminates due to a failure during execution* prior to shutdown, a new one will take its place if needed to* execute subsequent tasks.  The threads in the pool will exist* until it is explicitly {@link ExecutorService#shutdown shutdown}.** @param nThreads the number of threads in the pool* @return the newly created thread pool* @throws IllegalArgumentException if {@code nThreads <= 0}*/public static ExecutorService newFixedThreadPool(int nThreads) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());}