ThreadPoolExecutor面试题 及源码分析

问题1

new ThreadPoolExecutor(10,100,10,TimeUnit.MILLISECONDS,new LinkedBlockingQueue(10));
一个这样创建的线程池，当已经有10个任务在运行时，第11个任务提交到此线程池执行的时候会发生什么，为什么？

先说答案

加入缓存队列。
当前线程数小于corePoolSize，则创建线程
当前线程数=corePoolSize，若仍有任务进来，则加入缓存队列
当前线程数=corePoolSize，缓存队列已满，仍有任务进来，创建新的线程，直至最大maxPoolSize

原因分析

源码：

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

源码说的很明确：

1. 如果线程数小于 corePoolSize 就新建线程
2. 尝试将其加入缓存队列
3. 加入失败就尝试创建新的线程

问题2

实现一个自定义的ThreadFactory的作用通常是？

答案

自定义线程名、是否为守护线程、指定一个UncaughtExceptionHandler（以便记录异常信息等）、指定线程优先级（可能会产生饥饿现象，不推荐使用）

• 守护线程：
  做一些辅助工作的线程，不会阻碍JVM的关闭。例如：周期性的从内存缓存中移除逾期的数据。如果只剩下守护线程，那么所有仍在运行的守护线程都将被抛弃

源码

  private static ThreadFactory build(ThreadFactoryBuilder builder) {
    final String nameFormat = builder.nameFormat;
    final Boolean daemon = builder.daemon;
    final Integer priority = builder.priority;
    final UncaughtExceptionHandler uncaughtExceptionHandler =
        builder.uncaughtExceptionHandler;
    final ThreadFactory backingThreadFactory =
        (builder.backingThreadFactory != null)
        ? builder.backingThreadFactory
        : Executors.defaultThreadFactory();
    final AtomicLong count = (nameFormat != null) ? new AtomicLong(0) : null;
    return new ThreadFactory() {
      @Override public Thread newThread(Runnable runnable) {
        Thread thread = backingThreadFactory.newThread(runnable);
        if (nameFormat != null) {
          thread.setName(format(nameFormat, count.getAndIncrement()));
        }
        if (daemon != null) {
          thread.setDaemon(daemon);
        }
        if (priority != null) {
          thread.setPriority(priority);
        }
        if (uncaughtExceptionHandler != null) {
          thread.setUncaughtExceptionHandler(uncaughtExceptionHandler);
        }
        return thread;
      }
    };
  }