JDK线程池学习笔记-1

之前使用用过线程池，但是就是看看文档接口复制粘贴过来用用而已，没有认真学习过，最近比较好奇线程池想学习一下，所以在此做个笔记。

JDK并发包中的线程池有：

ExecutorService single = Executors.newSingleThreadExecutor();

ExecutorService fixed = Executors.newFixedThreadPool(5);

ExecutorService cached = Executors.newCachedThreadPool();

ExecutorService scheduled = Executors.newScheduledThreadPool(5);

分别是：创建一个只有一个线程的线程池执行任务，没有得到执行的任务存储到队列中。

  创建一个固定大小的线程池，上面创建了5个线程的线程池。

创建一个缓存线程池，只要有任务没有线程处理就会创建线程处理，当有大量闲置线程时候根据策略销毁一些线程（策略此处不展开，以后描述）。

创建一个支持调度，定时的线程池，指定5个线程，支持增加线程。

接下来看一下JDK线程池的继承结构：



（此处复制于网络）

其中Executor是一个执行器，只有一个execute方法，源码如下：

package java.util.concurrent;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadPoolExecutor;

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

ExecutorService是一个执行服务，只要包含的是任务的提交，线程池关闭等操作，JDK源码如下：

package java.util.concurrent;

import java.util.List;
import java.util.Collection;
import java.security.PrivilegedAction;
import java.security.PrivilegedExceptionAction;

public interface ExecutorService extends Executor {

void shutdown();

List<Runnable> shutdownNow();

boolean isShutdown();

boolean isTerminated();

boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;

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

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

Future<?> submit(Runnable task);

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
throws InterruptedException;

<T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;

<T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}

AbstractExecutorService抽象类是对ExecutorService的部分方法实现，源码就不粘贴了。

ScheduledExecutorService接口继承了ExecutorService接口的一些方法声明，之后又添加了一些自己的调度，定时方法等特性。

ScheduledThreadPoolExecutor便是对ScheduledExecutorService的实现，同时继承至ThreadPoolExecutor，来支持一些非定时任务的执行特性。

这就是线程池的宏观继承结构。

接下来看一些具体实现，下面是简单入门的一个示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolStudy {

public static void main(String[] args) {

ExecutorService scheduled = Executors.newSingleThreadExecutor();

single.submit(new RunnableDemo());

single.shutdown();

}

}

class RunnableDemo implements Runnable {

@Override
public void run() {
System.out.println("run ...");
}

}

创建一个了一个单个线程的线程池，然后提交任务执行完毕之后关闭线程池。

第一步创建单个线程的线程池时候调用的是Executors的newSingleThreadExecutor方法。

Executors主要职责是定义： 

Executor

、

ExecutorService

、

ScheduledExecutorService

、

ThreadFactory

和

Callable

类的工厂和实用方法。

newSingleThreadExecutor方法源码如下：

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

发现内部创建了一个FinalizableDelegatedExecutorService对象，查看FinalizableDelegatedExecutorService声明发现：FinalizableDelegatedExecutorService继承于DelegatedExecutorService类。源码如下（java.util.concurrent.Executors.FinalizableDelegatedExecutorService）：

static class FinalizableDelegatedExecutorService//  是Executors的一个内部类
extends DelegatedExecutorService {
FinalizableDelegatedExecutorService(ExecutorService executor) {
super(executor);
}
protected void finalize() {
super.shutdown();
}
}

查看源码便知道FinalizableDelegatedExecutorService作用主要是在垃圾回收时候销毁线程。

在查看其父类源码，也是Executors的一个内部类，实现如下：

static class DelegatedExecutorService extends AbstractExecutorService {
private final ExecutorService e;
DelegatedExecutorService(ExecutorService executor) { e = executor; }
public void execute(Runnable command) { e.execute(command); }
public void shutdown() { e.shutdown(); }
public List<Runnable> shutdownNow() { return e.shutdownNow(); }
public boolean isShutdown() { return e.isShutdown(); }
public boolean isTerminated() { return e.isTerminated(); }
public boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException {
return e.awaitTermination(timeout, unit);
}
public Future<?> submit(Runnable task) {
return e.submit(task);
}
public <T> Future<T> submit(Callable<T> task) {
return e.submit(task);
}
public <T> Future<T> submit(Runnable task, T result) {
return e.submit(task, result);
}
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException {
return e.invokeAll(tasks);
}
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException {
return e.invokeAll(tasks, timeout, unit);
}
public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException {
return e.invokeAny(tasks);
}
public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
return e.invokeAny(tasks, timeout, unit);
}
}

重点：由于Single线程池的功能比较简单， 返回代理对象目的是屏蔽掉掉newSingle***不需要的方法

由注释可以知道DelegatedExecutorService类职责是：一个包装类，用来仅暴露ExecutorService实现类中的ExecutorService的方法，本实例中不适用代理的话正常应该返回一个ThreadPoolExecutor对象，但是由于不想暴露ThreadPoolExecutor的所有方法，所以返回代理对象。

同理：DelegatedScheduledExecutorService是ScheduledThreadPoolExecutor的一个代理类，不想暴露ScheduledExecutorService的所有方法。

// FinalizableDelegatedExecutorService
System.out.println(Executors.newSingleThreadExecutor());

// DelegatedScheduledExecutorService
System.out.println(Executors.newSingleThreadScheduledExecutor());

以上都是返回代理对象！
拓展，代理的实现：把被代理对象放到代理对象中，作为一个私有成员变量，然后对被代理的对象的部分想暴露出来的方法在代理对象中实现即可！






备注：ThreadPoolExecutor是

ExecutorService的

一个子类 ，它使用线程池中线程执行提交的任务，ScheduledThreadPoolExecutor也是

ExecutorService的

一个子类 ，它使用线程池中线程执行提交的任务。

进行小总结：FinalizableDelegatedExecutorService对象就是对代理对象DelegatedExecutorService又包了一层确保垃圾回收销毁线程。

但是FinalizableDelegatedExecutorService却没有对DelegatedScheduledExecutorService对象进行包层。具体什么原因呢？

对于非newSingle***的创建，返回的是对应的Executor：

// FinalizableDelegatedExecutorService
System.out.println(Executors.newSingleThreadExecutor());

// DelegatedScheduledExecutorService
System.out.println(Executors.newSingleThreadScheduledExecutor());

// ThreadPoolExecutor
System.out.println(Executors.newFixedThreadPool(5));

// ScheduledThreadPoolExecutor
System.out.println(Executors.newScheduledThreadPool(5));

// ThreadPoolExecutor
System.out.println(Executors.newCachedThreadPool());