Java 多线程编程-并发编程

Java 多线程编程-并发编程

Table of Contents Java 多线程编程-并发编程并发基础类之任务类Callable 接口Future 接口FutureTask 类 构造方法run()方法get()方法并发基础类之线程相关类ThreadFactory 接口ThreadGroup 类Executors.DefaultThreadFactory 类并发基础类之调度器Executor 接口ExecutorService 接口ScheduledExecutorService 接口AbstractExecutorService 抽象类ThreadPoolExecutor 类内部类 WorkerAtomicInteger Int 类型变量 ct1构造方法Excute() 方法线程池的管理ThreadPoolExecutor 使用教程

对于初学者来说，多线程就是 new 一个 Thread()，然后设置一个 Runnable，调用 Thread.start()方法启动线程。可是这种方式可能存在以下问题

子线程不可控制，不可取消（可以自行设置标志位，结束run方法），不可返回结果

创建新的线程，并且启动线程，需要抢占资源，可能会超过线程数，同时空闲的线程，没有被重新利用。

为此，这里会介绍两个内容点

并发编程基础：Callable 相关内容

多线程框架: Executor 相关内容

其中 Executor 的相关类图如下：

细节的介绍，可以看后面的文章。

并发基础类之任务类

Callable 接口

Callable 接口代码如下：

public interface Callable<V> {
/**执行方法，其中V表示返回的结果
*/
V call() throws Exception;
}

和 Runnable 类似，只不过提供了一个 call()方法，可以返回执行的结果，其泛型参数 表示结果类型。

Future 接口

Future 的代码如下：

public interface Future<V> {

/**
* Attempts to cancel execution of this task.  This attempt will
* fail if the task has already completed, has already been cancelled,
* or could not be cancelled for some other reason. If successful,
* and 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 should be interrupted in
* an attempt to stop the task.
* 取消任务，如果任务已经完成，已经被取消或者不可被取消，则取消失败。boolean 值参数表示是否可以取消      * 执行中的任务。
*/
boolean cancel(boolean mayInterruptIfRunning);

/**
* Returns {@code true} if this task was cancelled before it completed
* normally. 任务是否已经被取消
*/
boolean isCancelled();

/**
* Returns {@code true} if this task completed. 任务是否已经被完成
*/
boolean isDone();

/**
* Waits if necessary for the computation to complete, and then
* retrieves its result. 获取任务结果，如果任务没有完成，get 方法会阻塞
*
*/
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.
* 等同于 get()只不过，声明了最长阻塞时间，不会无限阻塞
*/
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}

总的来说， Future 接口， 提供了以下能力

获取任务结果（可阻塞）

取消任务，获取任务的简单状态（是否完成，是否被取消等）

这个是异步回调的基础接口，需要好好理解，但是实际上，我们并不会直接用它，而是实现它的子类 FutureTask ，具体的介绍，往后看。

FutureTask 类

FutureTask 类实现 RunnableFuture 接口，而 RunnableFuture接口的实现如下：

public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}

从这个角度看，我们可以知道 RunableFuture 实现的规范如下:

run() 方法，子任务执行的方法

get() 方法，获取子任务执行结果的能力

从 Future 结果继承的，取消子任务，获取子任务简单状态的方法

而 FutureTask 是 RunnableFuture 的具体实现类，根据官方的描述， FutureTask 是可取消的异步操作，提供了 Future 接口的具体实现，实现了开始和取消一个操作的，查询操作是否完成，获取操作结果的方法。它可以包裹一个 Callable 或者 Runnable 可以被 Executor 执行和调度。

我们来看下关键代码

public class FutureTask<V> implements RunnableFuture<V> {
/**
* 表示该任务的执行状态，只可能为以下四种情况
* Possible state transitions:
* NEW -> COMPLETING -> NORMAL 正常完成的流程 new -> completing -> normal
* NEW -> COMPLETING -> EXCEPTIONAL 异常退出的流程 new -> completing -> exceptional
* NEW -> CANCELLED 取消的流程 new -> cancelled
* NEW -> INTERRUPTING -> INTERRUPTED 被中断的流程 new -> interrupting -> interrupted
*/
private volatile int state;
private static final int NEW          = 0;
private static final int COMPLETING   = 1;
private static final int NORMAL       = 2;
private static final int EXCEPTIONAL  = 3;
private static final int CANCELLED    = 4;
private static final int INTERRUPTING = 5;
private static final int INTERRUPTED  = 6;
/** The underlying callable; nulled out after running  */
private Callable<V> callable;
/** The result to return or exception to throw from get() */
private Object outcome; // non-volatile, protected by state reads/writes
/** The thread running the callable; CASed during run() 工作线程，用于执行 Callable */
private volatile Thread runner;
/** Treiber stack of waiting threads */
private volatile WaitNode waiters;

// 两个构造方法是一样的，如果传递的是 Runnable 则会被封装成 Callable
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW;       // ensure visibility of callable
}
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW;       // ensure visibility of callable
}
}

构造方法

构造方法可以传递一个 Callable 或者 Runnable，但是实际上传递 Runnable 也好，最终还是通过 Excutors 工具类，将 Runnable 封装成 Callable，这里的话，会对 state 进行赋值，赋值为 new。

run()方法

public void run() {
if (state != NEW ||
!U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}

首先会判断任务的 State，如果 State 不为 new 则直接返回，然后执行 Callable 类型的类变量 callable 的call()方法，依旧构造方法里面传入的 Callable 对象。途中会捕获异常，如果发生异常，则将 result 置为null，并且设置 Exception，最后如果执行执行，则将 call()方法返回的结果，通过set()方法传递给outcome变量，最终通过get()等方法，获取的就是这个 outcome 泛型对象的值。

get()方法

get()方法用于获取任务执行的结果，如果状态还处于未完成的话，则改方法进行阻塞。

public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}

这里的关键方法是调用了 awaitDone() 方法，顾名思义，就是一个阻塞方法，其代码如下：

private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
long startTime = 0L;    // Special value 0L means not yet parked
WaitNode q = null;
boolean queued = false;
for (;;) {//进入一个无限循环中
int s = state;
if (s > COMPLETING) {//判断任务是否被完成，取消，或者中断
if (q != null)
q.thread = null;
return s;
}
else if (s == COMPLETING)//如果任务执行中，则 yeid 线程，yeid 不同于 sleep 和waite，仅仅
//在线程资源紧张的情况下，会暂停线程
// We may have already promised (via isDone) that we are done
// so never return empty-handed or throw InterruptedException
Thread.yield();
else if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
else if (q == null) {
if (timed && nanos <= 0L)
return s;
q = new WaitNode();//对 q 进行初始化，仅仅在 timed 传参为 true 的时候
}
else if (!queued)//加入队列，并且将 q.next 赋值给 wauters
queued = U.compareAndSwapObject(this, WAITERS,
q.next = waiters, q);
else if (timed) {//以下代码是计算阻塞时间的代码
final long parkNanos;
if (startTime == 0L) { // first time
startTime = System.nanoTime();
if (startTime == 0L)
startTime = 1L;
parkNanos = nanos;
} else {
long elapsed = System.nanoTime() - startTime;
if (elapsed >= nanos) {
removeWaiter(q);
return state;
}
parkNanos = nanos - elapsed;
}
// nanoTime may be slow; recheck before parking
if (state < COMPLETING)//LockSupport 是一个用来创建锁和其它同步类的基本线程元素类
LockSupport.parkNanos(this, parkNanos);//该线程会阻塞特定的事件
}
else
LockSupport.park(this);
}
}

waitDone()方法就是将当前线程加入等待队列(WaitNode 持有当前线程)，然后调用 LockSupport的park()方法，将线程阻塞，等待执行完成或者异常。那么这里的等待，又是在哪里被唤醒的呢？在 run()方法里,调用了 set()方法，最终调用了 finishCompletion()方法。

public void run() {
..................
if (ran)
set(result);
.................
}
protected void set(V v) {
if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
outcome = v;
U.putOrderedInt(this, STATE, NORMAL); // final state
finishCompletion();
}
}
/**
* Removes and signals all waiting threads, invokes done(), and
* nulls out callable.
*/
private void finishCompletion() {
// assert state > COMPLETING;
for (WaitNode q; (q = waiters) != null;) {
if (U.compareAndSwapObject(this, WAITERS, q, null)) {
for (;;) {
Thread t = q.thread;
if (t != null) {
q.thread = null;
LockSupport.unpark(t);//这里对进行 unPark(),接触线程阻塞
}
WaitNode next = q.next;
if (next == null)
break;
q.next = null; // unlink to help gc
q = next;
}
break;
}
}

done();

callable = null;        // to reduce footprint
}

FutureTask 中的同步操作，并没有使用锁机制，而是使用了 LockSupport 阻塞和唤起线程，锁操作的话，会额外的耗时。

总的来说，FuterTask 提供了，任务执行的方法，获取任务结果的方法，以及取消的机制，能够实现同步编程的基本操作。

并发基础类之线程相关类

ThreadFactory 接口

总是通过硬编码 new 一个 Thread是不优雅的，所以 java 提供了一个接口，用于实现new Thread这样一个操作，这样的话，你就可以生产出一些你需要的特殊 Thrad，例如达成某种任务的 Thread，高优先级的 Thread 等等。

public interface ThreadFactory {
Thread newThread(Runnable r);
}

总结：工厂模式，往往是为了减少业务耦合。

ThreadGroup 类

ThreadGroup 类，这个类主要是方便线程群的管理，统一设置线程的一些属性。

例如从 setMaxPriority() 方法说起，这个方法统一设置了线程群里面的优先级：

public final void setMaxPriority(int pri) {
int ngroupsSnapshot;
ThreadGroup[] groupsSnapshot;
synchronized (this) {
checkAccess();
// Android changed: Clamp to MIN_PRIORITY, MAX_PRIORITY.
// if (pri < Thread.MIN_PRIORITY || pri > Thread.MAX_PRIORITY) {
//     return;
// }
if (pri < Thread.MIN_PRIORITY) {
pri = Thread.MIN_PRIORITY;
}
if (pri > Thread.MAX_PRIORITY) {
pri = Thread.MAX_PRIORITY;
}

maxPriority = (parent != null) ? Math.min(pri, parent.maxPriority) : pri;
ngroupsSnapshot = ngroups;
if (groups != null) {
groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
} else {
groupsSnapshot = null;
}
}
for (int i = 0 ; i < ngroupsSnapshot ; i++) {
groupsSnapshot[i].setMaxPriority(pri);
}
}

这个方法主要是遍历类Thread 数组变量 ngroups，然后逐一给线程设置优先级。

总结：ThreadGroup 类，提供了线程组这样一个概念，这个组里面拥有的是一些属性相同的线程。至于实际用途，视开发场景而言。

Executors.DefaultThreadFactory 类

创建一个 ThreadPoolExecutor 如果不传递 ThreadFactory 的话，则会使用 DefaultThreadFactory。

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() {
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;
}
}

构造方法里面会通过 Thread.currentThread.getThreadGroup()创建一个 ThreadGroup，然后在 newThread() 方法里面，会给新加入的 Thread，设置 ThreadGroup，这样通过，这个 ThreadFactory 产生的 Thread，就具有一些统一的属性了。

题外话：ThreadGroup 里面使用了数组作为存储的数据结构，看起来好像不太好扩展，而且从数组不可变的角度来考虑，似乎无法理解这一点。

并发基础类之调度器

为什么需要调度器，我们考虑一些情况，如果一个应用进程里面，野蛮的 new 一些 Thread()出来，并且调用了线程的 start()，从操作系统角度考虑，这样肯定会造成资源竞争的，会带来以下一些缺点

资源竞争，重要的线程，可能被低优先级线程阻塞。

资源浪费，闲置的线程，无法被回收利用。

从 Android 的角度考虑， liunx 限制了最大线程数目，超过线程数目，会导致 OOM。

所以，需要线程调度器这样一个管理者的角色。Java从 jdk 1.5 开始在 java.util.concurrent 包里面提供了一系列相关的接口和类，实现这个能力。

先看下类图结构。

Executor接口 最基本的接口，实现了线程池的 excute()行为

ExecutorService接口 继承了 Executor 接口，实现了 shutdown(),submit()方法，扩展了停止任务，提交任务的能力

AbstractExecutorService抽象类 实现了 ExecutorService 接口里面的大部分方法

ThreadPoolExecutor 类 继承 AbstractExecutorService ，实现了线程池

ScheduledExecutorService接口 继承ExecutorService接口，提供了周期调度的能力

ScheduledThreadPoolExecutor类，周期调度的线程池

Executos 类，线程池的静态工厂方法，提供了四种便捷的线程池

Executor 接口

最基础的是 Executor 接口

public interface Executor {
/**
* Executes the given command at some time in the future.  The command
* may execute in a new thread, in a pooled thread, or in the calling
* thread, at the discretion of the {@code Executor} implementation.
*
*/
void execute(Runnable command);
}

这个接口类，提供了 excute()方法，可以执行提交一个任务，也就是 执行 Runnable 对象的 run()方法。

ExecutorService 接口

继承 Executor 接口，实现了一些拓展，较为基本的线程池接接口。

public interface ExecutorService extends Executor {

/**停止一次之前提交的任务
*/
void shutdown();

/**
* 停止所以正在执行的列表
* @return list of tasks that never commenced execution
*/
List<Runnable> shutdownNow();

/**
* Returns {@code true} if this executor has been shut down.
*
* @return {@code true} if this executor has been shut down
*/
boolean isShutdown();

/**
* 是否所以任务都被停止了，如果是，则返回 true
* @return {@code true} if all tasks have completed following shut down
*/
boolean isTerminated();

/**
* Blocks until all tasks have completed execution after a shutdown
* request, or the timeout occurs, or the current thread is
* interrupted, whichever happens first.
*
* @param timeout the maximum time to wait
* @param unit the time unit of the timeout argument
* @return {@code true} if this executor terminated and
*         {@code false} if the timeout elapsed before termination
* @throws InterruptedException if interrupted while waiting
*/
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;

/**
* Submits a value-returning task for execution and returns a
* Future representing the pending results of the task. The
* Future's {@code get} method will return the task's result upon
* successful completion.
* 提交一个 Callable，返回值为 Future,Future 的get()方法会在任务成功完成后，返回结果
* <p>
* If you would like to immediately block waiting
* for a task, you can use constructions of the form
* {@code result = exec.submit(aCallable).get();}
*
* <p>Note: The {@link Executors} class includes a set of methods
* that can convert some other common closure-like objects,
* for example, {@link java.security.PrivilegedAction} to
* {@link Callable} form so they can be submitted.
*
* @param task the task to submit
* @param <T> the type of the task's result
* @return a Future representing pending completion of the task
* @throws RejectedExecutionException if the task cannot be
*         scheduled for execution
* @throws NullPointerException if the task is null
*/
<T> Future<T> submit(Callable<T> task);

/**
* Submits a Runnable task for execution and returns a Future
* representing that task. The Future's {@code get} method will
* return the given result upon successful completion.
*
* @param task the task to submit
* @param result the result to return
* @param <T> the type of the result
* @return a Future representing pending completion of the task
* @throws RejectedExecutionException if the task cannot be
*         scheduled for execution
* @throws NullPointerException if the task is null
*/
<T> Future<T> submit(Runnable task, T result);

/**
* Submits a Runnable task for execution and returns a Future
* representing that task. The Future's {@code get} method will
* return {@code null} upon <em>successful</em> completion.
*
* @param task the task to submit
* @return a Future representing pending completion of the task
* @throws RejectedExecutionException if the task cannot be
*         scheduled for execution
* @throws NullPointerException if the task is null
*/
Future<?> submit(Runnable task);

/**
* Executes the given tasks, returning a list of Futures holding
* their status and results when all complete.
* {@link Future#isDone} is {@code true} for each
* element of the returned list.
* Note that a <em>completed</em> task could have
* terminated either normally or by throwing an exception.
* The results of this method are undefined if the given
* collection is modified while this operation is in progress.
*
* @param tasks the collection of tasks
* @param <T> the type of the values returned from the tasks
* @return a list of Futures representing the tasks, in the same
*         sequential order as produced by the iterator for the
*         given task list, each of which has completed
* @throws InterruptedException if interrupted while waiting, in
*         which case unfinished tasks are cancelled
* @throws NullPointerException if tasks or any of its elements are {@code null}
* @throws RejectedExecutionException if any task cannot be
*         scheduled for execution
*/
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;

/**
* Executes the given tasks, returning a list of Futures holding
* their status and results
* when all complete or the timeout expires, whichever happens first.
* {@link Future#isDone} is {@code true} for each
* element of the returned list.
* Upon return, tasks that have not completed are cancelled.
* Note that a <em>completed</em> task could have
* terminated either normally or by throwing an exception.
* The results of this method are undefined if the given
* collection is modified while this operation is in progress.
*
* @param tasks the collection of tasks
* @param timeout the maximum time to wait
* @param unit the time unit of the timeout argument
* @param <T> the type of the values returned from the tasks
* @return a list of Futures representing the tasks, in the same
*         sequential order as produced by the iterator for the
*         given task list. If the operation did not time out,
*         each task will have completed. If it did time out, some
*         of these tasks will not have completed.
* @throws InterruptedException if interrupted while waiting, in
*         which case unfinished tasks are cancelled
* @throws NullPointerException if tasks, any of its elements, or
*         unit are {@code null}
* @throws RejectedExecutionException if any task cannot be scheduled
*         for execution
*/
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;

/**
* Executes the given tasks, returning the result
* of one that has completed successfully (i.e., without throwing
* an exception), if any do. Upon normal or exceptional return,
* tasks that have not completed are cancelled.
* The results of this method are undefined if the given
* collection is modified while this operation is in progress.
*
* @param tasks the collection of tasks
* @param <T> the type of the values returned from the tasks
* @return the result returned by one of the tasks
* @throws InterruptedException if interrupted while waiting
* @throws NullPointerException if tasks or any element task
*         subject to execution is {@code null}
* @throws IllegalArgumentException if tasks is empty
* @throws ExecutionException if no task successfully completes
* @throws RejectedExecutionException if tasks cannot be scheduled
*         for execution
*/
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException;

/**
* Executes the given tasks, returning the result
* of one that has completed successfully (i.e., without throwing
* an exception), if any do before the given timeout elapses.
* Upon normal or exceptional return, tasks that have not
* completed are cancelled.
* The results of this method are undefined if the given
* collection is modified while this operation is in progress.
*
* @param tasks the collection of tasks
* @param timeout the maximum time to wait
* @param unit the time unit of the timeout argument
* @param <T> the type of the values returned from the tasks
* @return the result returned by one of the tasks
* @throws InterruptedException if interrupted while waiting
* @throws NullPointerException if tasks, or unit, or any element
*         task subject to execution is {@code null}
* @throws TimeoutException if the given timeout elapses before
*         any task successfully completes
* @throws ExecutionException if no task successfully completes
* @throws RejectedExecutionException if tasks cannot be scheduled
*         for execution
*/
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}

void shutdown()

停止任务，但是不会等待之前提交任务完成之后，再停止

List showdownNow()

停止只在执行和等待执行的任务，并且返回等待执行的任务列表

Future submit(Callable task)

提交一个 Callable 类型的任务，返回一个可获取结果的 Future 对象，Future.get()方法会返回结果，直到任务完成。

Future