线程池那点事

1. 概述
   线程池是一个形象的说法，将程序运行所需的线程资源统一放在一起，线程池（相当于管理员的角色）管理这些资源。将任务提交给线程池，由线程池负责资源调度及分配线程执行任务。显然，这样的管理使线程得到极好的复用，节省了资源，效率也更高。
2. 常用类及类图
   • Executor
     • 顶层接口，定义执行任务的标准
     • 位于java.util.concurrent包下

public interface Executor {
    void execute(Runnable command);

- ExecutorService
    - 继承了Executor,扩展出一套执行任务的标准
    - 位于java.util.concurrent包下

public interface ExecutorService extends Executor {

    void shutdown();

    List<Runnable> shutdownNow();

    boolean isShutdown();

    boolean isTerminated();

    <T> Future<T> submit(Callable<T> task);

    <T> Future<T> submit(Runnable task, T result);


    Future<?> submit(Runnable task);
}

- Callable
    - 封装需要被线程/线程池执行的任务
    - 带返回值

public interface Callable<V> {
    V call() throws Exception;
}

- Runnable
    - 封装需要被线程/线程池执行的任务
    - 不带返回值

public
interface Runnable {
    public abstract void run();
}

- Executors
    - 工具类
    - 操作Execoutor、ExecoutorService及其子类

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

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

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

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

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

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

        public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
            return new DelegatedScheduledExecutorService
                (new ScheduledThreadPoolExecutor(1));
        }
    

        public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
            return new DelegatedScheduledExecutorService
                (new ScheduledThreadPoolExecutor(1, threadFactory));
        }
    

        public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
            return new ScheduledThreadPoolExecutor(corePoolSize);
        }
    

        public static ScheduledExecutorService newScheduledThreadPool(
                int corePoolSize, ThreadFactory threadFactory) {
            return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
        }
    
        public static <T> Callable<T> callable(Runnable task, T result) {
            if (task == null)
                throw new NullPointerException();
            return new RunnableAdapter<T>(task, result);
        }

        public static Callable<Object> callable(Runnable task) {
            if (task == null)
                throw new NullPointerException();
            return new RunnableAdapter<Object>(task, null);
        }
    

        public static Callable<Object> callable(final PrivilegedAction<?> action) {
            if (action == null)
                throw new NullPointerException();
            return new Callable<Object>() {
                public Object call() { return action.run(); }};
        }
    

        public static Callable<Object> callable(final PrivilegedExceptionAction<?> action) {
            if (action == null)
                throw new NullPointerException();
            return new Callable<Object>() {
                public Object call() throws Exception { return action.run(); }};
        }
    

        public static <T> Callable<T> privilegedCallable(Callable<T> callable) {
            if (callable == null)
                throw new NullPointerException();
            return new PrivilegedCallable<T>(callable);
        }
    
        public static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable) {
            if (callable == null)
                throw new NullPointerException();
            return new PrivilegedCallableUsingCurrentClassLoader<T>(callable);
        }
    
        /** Cannot instantiate. */
        private Executors() {}
    }
    
    ```
    - ThreadPoolExecutor
        - 线程池执行器

```java

public class ThreadPoolExecutor extends AbstractExecutorService{
}

public abstract class AbstractExecutorService implements ExecutorService {
}

ThreadPoolExecoutor类图

- Future
- 定义任务执行的结果的通用方法

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}


    ```

    - FutureTask
        - 包装需要执行的任务，可获取任务执行的结果

```java
public class FutureTask<V> implements RunnableFuture<V> {}


public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

FutureTask类图

- ForkJoinPool

ForkJoinPool

3. 示例
4. 总结