Java---线程池

An {@link ExecutorService} that executes each submitted task using one of possibly 
several pooled threads, normally configured using {@link Executors} factory methods.

public class ThreadPoolExecutor extends AbstractExecutorService 
public abstract class AbstractExecutorService implements ExecutorService
public interface ExecutorService extends Executor {
    void shutdown();    // 关闭所有任务
    List<Runnable> shutdownNow();   // 立即关闭所有任务
    boolean isShutdown();       // 是否被关闭
    boolean isTerminated();     // 是否被终止运行
    Future<?> submit(Runnable task);    // 提交任务到线程池中运行，最后还是交于execute方法执行
    ....
}
public interface Executor {
    void execute(Runnable command); // 执行任务
}

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) {
    ....                              
}

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(1000);
                return "callable sleep 1s";
            }
        };
        Callable<String> callable1 = new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(2000);
                return "callable sleep 2s";
            }
        };
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("I'm runnable. I'm finished.");
            }
        });
        Future<String> submit = executorService.submit(callable);
        Future<String> submit1 = executorService.submit(callable1);
        String s = submit.get();
        String s1 = submit1.get();
        System.out.println("callable resule: s=>" + s + "  s1=>" + s1);
    }
}

输出：
I'm runnable. I'm finished.
callable resule: s=>callable sleep 1s  s1=>callable sleep 2s

/**
 * <dt>Hook methods</dt>
 *
 * <dd>This class provides {@code protected} overridable
 * {@link #beforeExecute(Thread, Runnable)} and
 * {@link #afterExecute(Runnable, Throwable)} methods that are called
 * before and after execution of each task.  These can be used to
 * manipulate the execution environment; for example, reinitializing
 * ThreadLocals, gathering statistics, or adding log entries.
 */

class PausableThreadPoolExecutor extends ThreadPoolExecutor {
   private boolean isPaused;
   private ReentrantLock pauseLock = new ReentrantLock();
   private Condition unpaused = pauseLock.newCondition();

   public PausableThreadPoolExecutor(...) { super(...); }

   protected void beforeExecute(Thread t, Runnable r) {
     super.beforeExecute(t, r);
     pauseLock.lock();
     try {
       while (isPaused) unpaused.await();
     } catch (InterruptedException ie) {
       t.interrupt();
     } finally {
       pauseLock.unlock();
     }
   }

   public void pause() {
     pauseLock.lock();
     try {
       isPaused = true;
     } finally {
       pauseLock.unlock();
     }
   }

   public void resume() {
     pauseLock.lock();
     try {
       isPaused = false;
       unpaused.signalAll();
     } finally {
       pauseLock.unlock();
     }
   }
}