public class SingleThreadWebServer {

  public static void main(String[] args) throws IOException {
    ServerSocket socket = new ServerSocket(80);
    while (true) {
      Socket connection = socket.accept();
      handleRequest(connection);
    }
  }

  private static void handleRequest(Socket connection) {
    // handle request
  }
}

public class ThreadPerTaskWebServer {

  public static void main(String[] args) throws IOException {
    ServerSocket socket = new ServerSocket(80);
    while (true) {
      Socket connection = socket.accept();
      new Thread(() -> handleRequest(connection)).start();
    }
  }

  private static void handleRequest(Socket connection) {
    // handle request
  }
}

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

public class TaskExecutionWebServer {

  private static final int NTHREADS = 100;

  private static final Executor executor = Executors.newFixedThreadPool(NTHREADS);

  public static void main(String[] args) throws IOException {
    ServerSocket socket = new ServerSocket(80);
    while (true) {
      Socket connection = socket.accept();
      executor.execute(() -> handleRequest(connection));
    }
  }

  private static void handleRequest(Socket connection) {
    // handle request
  }
}

public interface ExecutorService extends Executor{
  	void shutdown（）；
    List＜Runnable＞shutdownNow（）；
    boolean isShutdown（）；
    boolean isTerminated（）；
    boolean awaitTermination（long timeout, TimeUnit unit）throws InterruptedException；
      //……其他用于任务提交的便利方法
}

public class LifecycleWebServer {

  private static final int NTHREADS = 100;

  private static final ExecutorService executor = Executors.newFixedThreadPool(NTHREADS);

  public static void main(String[] args) throws IOException {
    ServerSocket socket = new ServerSocket(80);
    while (!executor.isShutdown()) {
      try {
        Socket connection = socket.accept();
        executor.execute(() -> handleRequest(connection));
      } catch (RejectedExecutionException e) {
        if (!executor.isShutdown()) {
          log("task submission rejected", e);
        }
      }
    }
  }

  public static void stop() {
    executor.shutdown();
  }

  private static void log(String msg, Exception e) {
    Logger.getAnonymousLogger().log(Level.WARNING, msg, e);
  }

  private static void handleRequest(Socket connection) {
    // handle request
  }
}

public abstract class SingleThreadRenderer {

  void renderPage(CharSequence source) {
    rendText(source);

    List<ImageData> imageDataList = new ArrayList<>();
    for (ImageInfo imageInfo : scanForImageInfo(source)) {
      imageDataList.add(imageInfo.downloadImage());
    }

    for (ImageData imageData : imageDataList) {
      renderImage(imageData);
    }
  }

  abstract void rendText(CharSequence source);

  abstract List<ImageInfo> scanForImageInfo(CharSequence source);

  abstract void renderImage(ImageData imageData);

  interface ImageData {}

  interface ImageInfo {
    ImageData downloadImage();
  }
}

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

public interface Future<V> {

    /**
     * Attempts to cancel execution of this task.  This method has no
     * effect if the task is already completed or cancelled, or could
     * not be cancelled for some other reason.  Otherwise, if this
     * task has not started when {@code cancel} is called, this task
     * should never run.  If the task has already started, then the
     * {@code mayInterruptIfRunning} parameter determines whether the
     * thread executing this task (when known by the implementation)
     * is interrupted in an attempt to stop the task.
     *
     * <p>The return value from this method does not necessarily
     * indicate whether the task is now cancelled; use {@link
     * #isCancelled}.
     *
     * @param mayInterruptIfRunning {@code true} if the thread
     * executing this task should be interrupted (if the thread is
     * known to the implementation); otherwise, in-progress tasks are
     * allowed to complete
     * @return {@code false} if the task could not be cancelled,
     * typically because it has already completed; {@code true}
     * otherwise. If two or more threads cause a task to be cancelled,
     * then at least one of them returns {@code true}. Implementations
     * may provide stronger guarantees.
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     * Returns {@code true} if this task was cancelled before it completed
     * normally.
     *
     * @return {@code true} if this task was cancelled before it completed
     */
    boolean isCancelled();

    /**
     * Returns {@code true} if this task completed.
     *
     * Completion may be due to normal termination, an exception, or
     * cancellation -- in all of these cases, this method will return
     * {@code true}.
     *
     * @return {@code true} if this task completed
     */
    boolean isDone();

    /**
     * Waits if necessary for the computation to complete, and then
     * retrieves its result.
     *
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException if the computation threw an
     * exception
     * @throws InterruptedException if the current thread was interrupted
     * while waiting
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     * Waits if necessary for at most the given time for the computation
     * to complete, and then retrieves its result, if available.
     *
     * @param timeout the maximum time to wait
     * @param unit the time unit of the timeout argument
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException if the computation threw an
     * exception
     * @throws InterruptedException if the current thread was interrupted
     * while waiting
     * @throws TimeoutException if the wait timed out
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

public abstract class FutureRenderer {

  private final ExecutorService executor = Executors.newFixedThreadPool(100);

  void renderPage(CharSequence source) {

    List<ImageInfo> imageInfos = scanForImageInfo(source);

    Future<List<ImageData>> future =
        executor.submit(
            () -> {
              List<ImageData> imageDataList = new ArrayList<>();
              for (ImageInfo imageInfo : imageInfos) {
                imageDataList.add(imageInfo.downloadImage());
              }
              return imageDataList;
            });

    rendText(source);

    try {
      List<ImageData> imageDataList = future.get();
      for (ImageData imageData : imageDataList) {
        renderImage(imageData);
      }
    } catch (InterruptedException e) {
      // 重新设置线程的中断状态
      Thread.currentThread().interrupt();
      // 由于不需要结果，因此取消任务
      future.cancel(true);
    } catch (ExecutionException e) {
      throw LaunderThrowable.launderThrowable(e);
    }
  }

  abstract void rendText(CharSequence source);

  abstract List<ImageInfo> scanForImageInfo(CharSequence source);

  abstract void renderImage(ImageData imageData);

  interface ImageData {}

  interface ImageInfo {
    ImageData downloadImage();
  }
}

private static class QueueingFuture<V> extends FutureTask<Void> {
  QueueingFuture(RunnableFuture<V> task,
                 BlockingQueue<Future<V>> completionQueue) {
    super(task, null);
    this.task = task;
    this.completionQueue = completionQueue;
  }
  private final Future<V> task;
  private final BlockingQueue<Future<V>> completionQueue;
  protected void done() { completionQueue.add(task); }
}

public abstract class Render {

  private final ExecutorService executor;

  public Render(ExecutorService executor) {
    this.executor = executor;
  }

  void renderPage(CharSequence source) {
    List<ImageInfo> imageInfos = scanForImageInfo(source);
    CompletionService<ImageData> completionService = new ExecutorCompletionService<>(executor);

    for (ImageInfo imageInfo : imageInfos) {
      completionService.submit(imageInfo::downloadImage);
    }

    renderText(source);

    int size = imageInfos.size();
    try {
      for (int i = 0; i < size; i++) {
        Future<ImageData> imageDataFuture = completionService.take();
        ImageData imageData = imageDataFuture.get();
        renderImage(imageData);
      }
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    } catch (ExecutionException e) {
      throw LaunderThrowable.launderThrowable(e);
    }
  }

  protected abstract List<ImageInfo> scanForImageInfo(CharSequence source);

  protected abstract void renderText(CharSequence source);

  protected abstract void renderImage(ImageData imageData);

  interface ImageData {}

  interface ImageInfo {
    ImageData downloadImage();
  }
}

public class RenderWithTimeBudget {

  private static final Ad DEFAULT_AD = new Ad();
  private static final long TIME_BUDGET = 1000;
  private static final ExecutorService exec = Executors.newCachedThreadPool();

  Page renderPageWithAd() throws InterruptedException {
    long end = System.nanoTime() + TIME_BUDGET;
    Future<Ad> f = exec.submit(Ad::new);
    Page page = renderPageBody();

    Ad ad;
    try {
      long timeLeft = end - System.nanoTime();
      ad = f.get(timeLeft, TimeUnit.NANOSECONDS);
    } catch (ExecutionException e) {
      ad = DEFAULT_AD;
    } catch (TimeoutException e) {
      ad = DEFAULT_AD;
      f.cancel(true);
    }

    page.setAd(ad);
    return page;
  }

  private Page renderPageBody() {
    return new Page();
  }

  static class Ad {}

  static class Page {
    public void setAd(Ad ad) {}
  }
}

public class TimeBudget {

  private static ExecutorService executor = Executors.newCachedThreadPool();

  public List<TravelQuote> getRankedTravelQuotes(
      TravelInfo travelInfo,
      Set<TravelCompany> companies,
      Comparator<TravelQuote> ranking,
      long time,
      TimeUnit unit)
      throws InterruptedException {
    List<QuoteTask> tasks = new ArrayList<>();
    for (TravelCompany company : companies) {
      tasks.add(new QuoteTask(company, travelInfo));
    }

    List<Future<TravelQuote>> futures = executor.invokeAll(tasks, time, unit);

    List<TravelQuote> quotes = new ArrayList<>(tasks.size());
    for (Future<TravelQuote> future : futures) {
      for (QuoteTask task : tasks) {
        try {
          quotes.add(future.get());
        } catch (ExecutionException e) {
          quotes.add(task.getFailureQuote(e.getCause()));
        } catch (CancellationException e) {
          quotes.add(task.getTimeoutQuote(e));
        }
      }
    }

    quotes.sort(ranking);

    return quotes;
  }

  static class QuoteTask implements Callable<TravelQuote> {
    private final TravelCompany company;
    private final TravelInfo travelInfo;

    public QuoteTask(TravelCompany company, TravelInfo travelInfo) {
      this.company = company;
      this.travelInfo = travelInfo;
    }

    TravelQuote getFailureQuote(Throwable t) {
      return null;
    }

    TravelQuote getTimeoutQuote(CancellationException e) {
      return null;
    }

    @Override
    public TravelQuote call() throws Exception {
      return company.solicitQuote(travelInfo);
    }
  }
}

interface TravelCompany {
  TravelQuote solicitQuote(TravelInfo travelInfo) throws Exception;
}

interface TravelQuote {}

interface TravelInfo {}

public class PrimeGenerator implements Runnable {

  @GuardedBy("this")
  private final List<BigInteger> primes = new ArrayList<>();

  private volatile boolean cancelled;

  @Override
  public void run() {
    BigInteger p = BigInteger.ONE;
    while (!cancelled) {
      p = p.nextProbablePrime();
      synchronized (this) {
        primes.add(p);
      }
    }
  }

  public void cancel() {
    cancelled = true;
  }

  public synchronized List<BigInteger> get() {
    return new ArrayList<>(primes);
  }

  static List<BigInteger> aSecondOfPrimes() throws InterruptedException {
    PrimeGenerator generator = new PrimeGenerator();
    new Thread(generator).start();
    try {
      SECONDS.sleep(1);
    } finally {
      generator.cancel();
    }
    return generator.get();
  }
}

@Terrible
public class BrokenPrimeProducer extends Thread {
  private final BlockingQueue<BigInteger> queue;
  private volatile boolean cancelled = false;

  public BrokenPrimeProducer(BlockingQueue<BigInteger> queue) {
    this.queue = queue;
  }

  @Override
  public void run() {
    BigInteger p = BigInteger.ONE;
    try {
      while (!cancelled) {
        queue.put(p.nextProbablePrime());
      }
    } catch (InterruptedException consumed) {
    }
  }

  public void cancel() {
    cancelled = true;
  }

  void consumePrimes() throws InterruptedException {
    BlockingQueue<BigInteger> primes = new ArrayBlockingQueue<>(100);
    BrokenPrimeProducer producer = new BrokenPrimeProducer(primes);
    producer.start();
    try {
      while (needMorePrimes()) {
        consume(primes.take());
      }
    } finally {
      producer.cancel();
    }
  }

  private boolean needMorePrimes() {
    return true;
  }

  private void consume(BigInteger take) {}
}

public class Thread {
  public void interrupt（）{……}
  public boolean isInterrupted（）{……}
  public static boolean interrupted（）{……}
  ……
}

public class PrimeProducer extends Thread {
  private final BlockingQueue<BigInteger> queue;

  public PrimeProducer(BlockingQueue<BigInteger> queue) {
    this.queue = queue;
  }

  @Override
  public void run() {
    try {
      BigInteger p = BigInteger.ONE;
      while (!Thread.currentThread().isInterrupted()) {
        queue.put(p = p.nextProbablePrime());
      }
    } catch (InterruptedException ignored) {
      // allow thread exit
    }
  }

  public void cancel() {
    interrupt();
  }
}

Thread.currentThread().interrupt();

public class NonCancelableTask {
  public Task getNextTask(BlockingQueue<Task> queue) {
    boolean interrupted = false;
    try {
      while (true) {
        try {
          return queue.take();
        } catch (InterruptedException e) {
          interrupted = true;
          // fall through and retry
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }

  interface Task {}
}

public class TimedRun1 {

  private static final ScheduledExecutorService cancelExec = Executors.newScheduledThreadPool(1);

  public static void timedRun(Runnable r, long timeout, TimeUnit unit) {
    Thread taskThread = Thread.currentThread();
    cancelExec.schedule(taskThread::interrupt, timeout, unit);
    r.run();
  }
}

public class TimedRun2 {

  private static final ScheduledExecutorService cancelExec = newScheduledThreadPool(1);

  public static void timedRun(Runnable r, long timeout, TimeUnit unit) throws InterruptedException {
    class RethrowableTask implements Runnable {
      private volatile Throwable t;

      @Override
      public void run() {
        try {
          r.run();
        } catch (Throwable t) {
          this.t = t;
        }
      }

      void rethrow() {
        if (t != null) {
          throw launderThrowable(t);
        }
      }
    }

    RethrowableTask task = new RethrowableTask();
    Thread taskThread = new Thread(task);
    taskThread.start();
    cancelExec.schedule(
        new Runnable() {
          @Override
          public void run() {
            taskThread.interrupt();
          }
        },
        timeout,
        unit);
    taskThread.join(unit.toMillis(timeout));
    task.rethrow();
  }
}

public class TimedRun {

  private static final ExecutorService executor = Executors.newCachedThreadPool();

  public static void timeRun(Runnable r, long timeout, TimeUnit unit) throws InterruptedException {
    Future<?> future = executor.submit(r);

    try {
      future.get(timeout, unit);
    } catch (ExecutionException e) {
      throw LaunderThrowable.launderThrowable(e);
    } catch (TimeoutException e) {
      // task will be cancelled below
    } finally {
      // Harmless if task already completed
      future.cancel(true);
    }
  }
}

public class ReaderThread extends Thread {

  private static final int BUFSZ = 1024;

  private final Socket socket;
  private final InputStream is;

  public ReaderThread(Socket socket) throws IOException {
    this.socket = socket;
    is = socket.getInputStream();
  }

  @Override
  public void run() {
    try {
      byte[] bytes = new byte[BUFSZ];
      while (true) {
        int count = is.read(bytes);
        if (count < 0) {
          break;
        } else if (count > 0) {
          processBuffer(bytes, count);
        }
      }
    } catch (IOException ignored) {
      /*允许线程退出*/
    }
  }

  private void processBuffer(byte[] bytes, int count) {}

  @Override
  public void interrupt() {

    try {
      socket.close();
    } catch (IOException ignored) {
    } finally {
      super.interrupt();
    }
  }
}

public class SocketUsingTask<T> implements CancellableTask<T> {

  @GuardedBy("this")
  private Socket socket;

  public SocketUsingTask<T> setSocket(Socket socket) {
    this.socket = socket;
    return this;
  }

  @Override
  public void cancel() {
    try {
      if (socket != null) {
        socket.close();
      }
    } catch (IOException ignored) {
      // ignored
    }
  }

  @Override
  public RunnableFuture<T> newTask() {
    return new FutureTask<>(this) {
      @Override
      public boolean cancel(boolean mayInterruptIfRunning) {
        try {
          SocketUsingTask.this.cancel();
        } finally {
          return super.cancel(mayInterruptIfRunning);
        }
      }
    };
  }

  @Override
  public T call() throws Exception {
    // 此处读取 Socket
    return null;
  }
}

interface CancellableTask<T> extends Callable<T> {
  void cancel();

  RunnableFuture<T> newTask();
}

@ThreadSafe
class CancellingExecutor extends ThreadPoolExecutor {
  //....构造器

  @Override
  protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    if (callable instanceof CancellableTask) {
      return ((CancellableTask<T>) callable).newTask();
    } else {
      return super.newTaskFor(callable);
    }
  }
}

//不支持关闭的生产者-消费者日志服务
public class LogWriter {

  private final BlockingQueue<String> queue;
  private final LoggerThread logger;

  public LogWriter(BlockingQueue<String> queue, LoggerThread logger) {
    this.queue = queue;
    this.logger = logger;
  }

  public void start() {
    logger.start();
  }

  public void log(String msg) throws InterruptedException {
    queue.put(msg);
  }

  class LoggerThread extends Thread {
    private final PrintWriter writer;

    LoggerThread(PrintWriter writer) {
      this.writer = writer;
    }

    @Override
    public void run() {
      try {
        while (true) {
          writer.println(queue.take());
        }
      } catch (InterruptedException ignored) {
        // ignored
      } finally {
        writer.close();
      }
    }
  }
}

public class LogService {

  private final BlockingQueue<String> queue;
  private final LoggerThread logger;

  @GuardedBy("this")
  private boolean isShutdown;

  @GuardedBy("this")
  private int reservations;

  public LogService(BlockingQueue<String> queue, LoggerThread logger) {
    this.queue = queue;
    this.logger = logger;
  }

  public void start() {
    logger.start();
  }

  public void stop() {
    synchronized (this) {
      isShutdown = true;
    }
    logger.interrupt();
  }

  public void log(String msg) throws InterruptedException {
    synchronized (this) {
      if (isShutdown) {
        throw new IllegalStateException("");
      }
      ++reservations;
    }
    queue.put(msg);
  }

  class LoggerThread extends Thread {
    private final PrintWriter writer;

    LoggerThread(PrintWriter writer) {
      this.writer = writer;
    }

    @Override
    public void run() {
      try {
        while (true) {
          try {
            synchronized (LogService.this) {
              if (isShutdown && reservations == 0) {
                break;
              }
            }

            String msg = queue.take();

            synchronized (this) {
              --reservations;
            }

            writer.println(msg);
          } catch (InterruptedException ignored) {
            // retry
          }
        }
      } finally {
        writer.close();
      }
    }
  }
}

public class LogServiceUseExecutorService {

  private final ExecutorService executor = Executors.newCachedThreadPool();
  private final PrintWriter writer;

  private final long timeout;
  private final TimeUnit unit;

  public LogServiceUseExecutorService(PrintWriter writer, long timeout, TimeUnit unit) {
    this.writer = writer;
    this.timeout = timeout;
    this.unit = unit;
  }

  public void stop() throws InterruptedException {
    try {
      executor.shutdown();
      executor.awaitTermination(timeout, unit);
    } finally {
      writer.close();
    }
  }

  public void log(String msg) {
    executor.execute(() -> writer.println(msg));
  }
}

public class IndexingService {

  private static final File POISON = new File("");
  private final CrawlerThread crawlerThread = new CrawlerThread();
  private final IndexerThread indexerThread = new IndexerThread();
  private final BlockingQueue<File> queue;
  private final FileFilter fileFilter;
  private final File root;

  public IndexingService(BlockingQueue<File> queue, FileFilter fileFilter, File root) {
    this.queue = queue;
    this.fileFilter = fileFilter;
    this.root = root;
  }

  public void start() {
    crawlerThread.start();
    indexerThread.start();
  }

  class CrawlerThread extends Thread {

    @Override
    public void run() {
      try {
        crawl(root);
      } catch (InterruptedException ignored) {
        // retry
      } finally {
        while (true) {
          try {
            queue.put(POISON);
          } catch (InterruptedException ignored) {
            // retry
          }
        }
      }
    }

    private void crawl(File root) throws InterruptedException {
      //
    }
  }

  class IndexerThread extends Thread {

    @Override
    public void run() {
      try {
        while (true) {
          File file = queue.take();
          if (file == POISON) {
            break;
          }
          indexFile(file);
        }
      } catch (InterruptedException ignored) {
        // ignored
      }
    }

    private void indexFile(File file) {
      //
    }
  }
}

public class CheckForEmail {

  public boolean checkEmail(Set<String> hosts, long timeout, TimeUnit unit)
      throws InterruptedException {

    ExecutorService executor = Executors.newCachedThreadPool();
    AtomicBoolean hasNewEmail = new AtomicBoolean(false);

    try {
      for (String host : hosts) {
        executor.execute(
            () -> {
              if (checkMail(host)) {
                hasNewEmail.set(true);
              }
            });
      }
    } finally {
      executor.shutdown();
      executor.awaitTermination(timeout, unit);
    }

    return hasNewEmail.get();
  }

  private boolean checkMail(String host) {
    return false;
  }
}

public class TrackingExecutor extends AbstractExecutorService {

  private final ExecutorService executor;
  private final Set<Runnable> taskCancelledAtShutdown =
      Collections.synchronizedSet(new HashSet<>());

  public TrackingExecutor(ExecutorService executor) {
    this.executor = executor;
  }

  @Override
  public void shutdown() {
    executor.shutdown();
  }

  @Override
  public List<Runnable> shutdownNow() {
    return executor.shutdownNow();
  }

  @Override
  public boolean isShutdown() {
    return executor.isShutdown();
  }

  @Override
  public boolean isTerminated() {
    return executor.isTerminated();
  }

  @Override
  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    return executor.awaitTermination(timeout, unit);
  }

  @Override
  public void execute(Runnable command) {
    executor.execute(
        () -> {
          try {
            command.run();
          } finally {
            if (isShutdown() && Thread.currentThread().isInterrupted()) {
              taskCancelledAtShutdown.add(command);
            }
          }
        });
  }

  public List<Runnable> getCancelledTasks() {
    return new ArrayList<>(taskCancelledAtShutdown);
  }
}

public abstract class WebCrawler {

  private static final long TIMEOUT = 1000;
  private static final TimeUnit UNIT = TimeUnit.MILLISECONDS;
  private volatile TrackingExecutor executor;
  private final Set<URL> urlsToCrawl = new HashSet<>();

  public synchronized void start() {
    executor = new TrackingExecutor(Executors.newCachedThreadPool());
    for (URL url : urlsToCrawl) {
      submitCrawTask(url);
    }
    urlsToCrawl.clear();
  }

  public synchronized void stop() throws InterruptedException {
    try {
      saveUncrawled(executor.shutdownNow());
      if (executor.awaitTermination(TIMEOUT, UNIT)) {
        saveUncrawled(executor.getCancelledTasks());
      }
    } finally {
      executor = null;
    }
  }

  private void saveUncrawled(List<Runnable> uncrawled) {
    for (Runnable runnable : uncrawled) {
      urlsToCrawl.add(((CrawlTask) runnable).getPage());
    }
  }

  protected void submitCrawTask(URL url) {
    executor.execute(new CrawlTask(url));
  }

  protected abstract List<URL> processPage(URL url);

  private class CrawlTask implements Runnable {

    private final URL url;

    private CrawlTask(URL url) {
      this.url = url;
    }

    @Override
    public void run() {
      for (URL link : processPage(url)) {
        if (Thread.currentThread().isInterrupted()) {
          return;
        }
        submitCrawTask(link);
      }
    }

    public URL getPage() {
      return url;
    }
  }
}

public void run（）{
  Throwable thrown=null；
    try{
      while（！isInterrupted（））
        runTask（getTaskFromWorkQueue（））；
    } catch（Throwable e）{
      thrown = e；
    } finally {
      threadExited（this, thrown）；
    }
}

@FunctionalInterface
public interface UncaughtExceptionHandler {
  /**
         * Method invoked when the given thread terminates due to the
         * given uncaught exception.
         * <p>Any exception thrown by this method will be ignored by the
         * Java Virtual Machine.
         * @param t the thread
         * @param e the exception
         */
  void uncaughtException(Thread t, Throwable e);
}

@Terrible
public class ThreadDeadLock {

  static ExecutorService executor = Executors.newSingleThreadExecutor();

  static class LoadFileTask implements Callable<String> {

    private final String fileName;

    public LoadFileTask(String fileName) {
      this.fileName = fileName;
    }

    @Override
    public String call() throws Exception {
      return "";
    }
  }

  static class RenderPageTask implements Callable<String> {

    @Override
    public String call() throws Exception {

      Future<String> header = executor.submit(new LoadFileTask("header.html"));
      Future<String> footer = executor.submit(new LoadFileTask("footer.html"));

      String page = renderBody();

      // 将发生死锁，因为任务在等待自任务的结果
      return header.get() + page + footer.get();
    }

    private String renderBody() {
      return "";
    }
  }

  @Test
  @DisplayName("test_dead_lock")
  void test_dead_lock() throws Exception {
    RenderPageTask renderPageTask = new RenderPageTask();
    renderPageTask.call();
  }
}

int cpus = Runtime.getRuntime().availableProcessors();

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
  ....
}

public static class AbortPolicy implements RejectedExecutionHandler {

        public AbortPolicy() { }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

public static class DiscardPolicy implements RejectedExecutionHandler {

        public DiscardPolicy() { }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

public static class DiscardOldestPolicy implements RejectedExecutionHandler {

        public DiscardOldestPolicy() { }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }

public static class CallerRunsPolicy implements RejectedExecutionHandler {

  public CallerRunsPolicy() { }

  public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
      r.run();
    }
  }
}

public class BoundedExecutor {

  private final ExecutorService executorService;
  private final Semaphore semaphore;

  public BoundedExecutor(ExecutorService executorService, Semaphore semaphore) {
    this.executorService = executorService;
    this.semaphore = semaphore;
  }

  public void submitTask(Runnable command) throws InterruptedException {
    semaphore.acquire();
    try {
      executorService.execute(
          () -> {
            try {
              command.run();
            } finally {
              semaphore.release();
            }
          });
    } catch (RejectedExecutionException e) {
      semaphore.release();
    }
  }
}

public interface ThreadFactory {

    /**
     * Constructs a new {@code Thread}.  Implementations may also initialize
     * priority, name, daemon status, {@code ThreadGroup}, etc.
     *
     * @param r a runnable to be executed by new thread instance
     * @return constructed thread, or {@code null} if the request to
     *         create a thread is rejected
     */
    Thread newThread(Runnable r);
}

private 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() {
    @SuppressWarnings("removal")
    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;
  }
}

public class MyThreadFactory implements ThreadFactory {

  private final String poolName;

  public MyThreadFactory(String poolName) {
    this.poolName = poolName;
  }

  @Override
  public Thread newThread(Runnable r) {
    return new MyAppThread(r, poolName);
  }
}

public class MyAppThread extends Thread {
  public static final String DEFAULT_NAME = "MyAppThread";
  private static volatile boolean debugLifecycle = false;
  private static final AtomicInteger created = new AtomicInteger();
  private static final AtomicInteger alive = new AtomicInteger();
  private static final Logger log = Logger.getAnonymousLogger();

  public MyAppThread(Runnable r) {
    this(r, DEFAULT_NAME);
  }

  public MyAppThread(Runnable runnable, String name) {
    super(runnable, name + "-" + created.incrementAndGet());
    setUncaughtExceptionHandler(
        (t, e) -> log.log(Level.SEVERE, "UNCAUGHT in thread " + t.getName(), e));
  }

  @Override
  public void run() {
    // Copy debug flag to ensure consistent value throughout.
    boolean debug = debugLifecycle;
    if (debug) {
      log.log(Level.FINE, "Created " + getName());
    }
    try {
      alive.incrementAndGet();
      super.run();
    } finally {
      alive.decrementAndGet();
      if (debug) {
        log.log(Level.FINE, "Exiting " + getName());
      }
    }
  }

  public static int getThreadsCreated() {
    return created.get();
  }

  public static int getThreadsAlive() {
    return alive.get();
  }

  public static boolean getDebug() {
    return debugLifecycle;
  }

  public static void setDebug(boolean b) {
    debugLifecycle = b;
  }
}

public class TimingThreadPool extends ThreadPoolExecutor {

  private static final ThreadLocal<Long> startTime = new ThreadLocal<>();
  private final Logger log = Logger.getLogger("TimingThreadPool");
  private final AtomicLong numTasks = new AtomicLong();
  private final AtomicLong totalTime = new AtomicLong();

  @Override
  protected void beforeExecute(Thread t, Runnable r) {
    super.beforeExecute(t, r);
    log.fine(String.format("Thread %s: start %s", t, r));
    startTime.set(System.nanoTime());
  }

  @Override
  protected void afterExecute(Runnable r, Throwable t) {
    try {
      long endTime = System.nanoTime();
      long taskTime = endTime - startTime.get();
      numTasks.incrementAndGet();
      totalTime.addAndGet(taskTime);
      log.fine(String.format("Thread %s : end %s, time= %dns", t, r, taskTime));
    } finally {
      super.afterExecute(r, t);
    }
  }

  @Override
  protected void terminated() {
    try {
      log.info(String.format("Terminated: avg time=%dns", totalTime.get() / numTasks.get()));
    } finally {
      super.terminated();
    }
  }
}