Java多线程之任务执行

一、在线程中执行任务

1.串行的执行任务

在应用程序中可以通过多种策略来调度任务，而其中的策略能够更好的利用潜在的并发性。最简单的策略就是在单个线程中串行的执行各项任务。

1public class SingleThreadWebServer {
2
3    public static void main(String args[]) throws IOException {
4        ServerSocket serverSocket = new ServerSocket(80);
5        while (true) {
6            Socket connetcion = serverSocket.accept();
7            handlerRequest();
8        }
9    }
10
11    public static void handlerRequest() {
12        return;
13    }
14}

它每次只能处理一个请求。当服务器正在处理请求时，新到来的连接必须等待直到请求处理完成。然后服务器再次调用accept方法。

2.显示地为任务创建线程

1public class ThreadPerTaskWebServer {
2
3    public static void main() throws IOException {
4        ServerSocket serverSocket = new ServerSocket(80);
5
6        while (true) {
7            Socket connection = serverSocket.accept();
8            Runnable task = new Runnable() {
9                @Override
10                public void run() {
11                    handlerRequest();
12                }
13            };
14            new Thread(task).start();
15        }
16    }
17
18    public static void handlerRequest() {
19        return;
20    }
21}

对于每个连接，主循环都将创建一个新线程来处理请求，而不是在主循环中进行处理。

3.无限制创建线程的不足

为每个任务分配一个线程的缺陷：

• 线程的生命周期的开销非常高：线程的创建与销毁并不是没有代价的。

• 资源的消耗：活跃的线程会消耗系统资源，尤其是内存。如果你已经拥有足够多的线程使所有CPU保持忙碌状态，那么再创建更多的线程反而会降低性能。

• 稳定性：在可创建线程的数量上存在一个限制。这个限制随着平台的不同而不同，并且受多个因素制约。

二、Executor框架

线程池简化了线程的管理工作，并且java.util.concurrent提供了一种灵活的线程池实现作为Executor框架的一部分。_在Java类库中，任务执行的主要抽象不是Thread，而是Executor。虽然Executor是个简单的接口，但他却为灵活且强大的异步任务执行框架提供了基础，该框架能支持多种不同类型的任务执行策略。_它提供了一种标准的方法将任务的提交过程与执行过程解耦开来，并用Runnable来表示任务。Executor的实现还提供了对生命周期的支持，以及统计信息收集、应用程序管理机制和性能监测机制。

_Executor基于生产者和消费者模式，提交任务的操作相当于生产者（生成待完成的工作单元），执行任务的线程则相当于消费者（执行完这些工作单元）。_如果要在程序中实现一个消费者-生产者的设计，那么最简单的方式通常就是使用Executor。

1.基于Executor的web服务器

1public class TaskExecutionWebServer {
2
3    private static final int NTHREADS = 100;
4    private static final Executor exec = Executors.newFixedThreadPool(NTHREADS);
5
6    public static void main(String args[]) throws IOException {
7        ServerSocket serverSocket = new ServerSocket(80);
8        while (true) {
9            final Socket connection = serverSocket.accept();
10            Runnable task = new Runnable() {
11                @Override
12                public void run() {
13                    handlerRequest(connection);
14                }
15            };
16            exec.execute(task);
17        }
18    }
19
20    private static void handlerRequest(Socket connection) {
21        return;
22    }
23
24}

通过使用Executor，将请求处理任务的提交与任务的实际执行解耦开来，并且只需采用另一种不同的Executor实现，就可以改变服务器的行为。

改变Executor实现或配置所带来的影响要远远小于改变任务提交方式带来的影响。通常Executor的配置是一次性的，因此在部署阶段可以完成，而提交任务的代码却会不断扩散到整个程序中，增加了修改的难度。

我们可以很容易地将TaskExecutionWebServer修改为类似ThreadPerTaskWebServer的行为，只需使用一个为每个请求都创建新线程的Executor。

1public class ThreadPerTaskExecutor extends Executor {
2
3    @Override
4    public void execute(Runnable command) {
5        new Thread(command).start();
6    }
7}

以同步方式执行所有任务的Executor

1public class WithinThreadExecutor implements Executor {
2
3    @Override
4    public void execute(Runnable command) {
5        command.run();
6    }
7}

2.线程池

在线程池中执行任务比为每一个任务分配一个线程优势更多。通过重用现有的线程而不是创建新线程，可以在处理多个请求时分摊在线程创建和销毁过程中产生的巨大开销。也不会由于等待创建线程而延迟任务的执行，从而提高了响应性。

‍可以通过调用Executors中的静态工厂方法之一来创建一个线程池‍

• newFixedThreadPool

• newCachedThreadPool

• newSingleThreadExecutor

• newSingleThreadScheduledExecutor

• newScheduledThreadPool

1/**
2 * 创建一个固定长度的线程池，每当提交一个任务时就创建一个线程，直到达到线程池的最大数量，这时线程池的规模将不再变化
3 */
4public static ExecutorService newFixedThreadPool(int nThreads) {
5    return new ThreadPoolExecutor(nThreads, nThreads,
6            0L, TimeUnit.MILLISECONDS,
7            new LinkedBlockingQueue<Runnable>());
8}
9
10
11public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
12    return new ThreadPoolExecutor(nThreads, nThreads,
13            0L, TimeUnit.MILLISECONDS,
14            new LinkedBlockingQueue<Runnable>(),
15            threadFactory);
16}
17
18/**
19 * 将创建一个可缓存的线程池，如果线程池的当前规模超过了处理需求时，那么将回收空闲的线程，而当需求增加时，则可以添加新的线程，线程池的规模不存在任何限制
20 * @return the newly created thread pool
21 */
22public static ExecutorService newCachedThreadPool() {
23    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
24            60L, TimeUnit.SECONDS,
25            new SynchronousQueue<Runnable>());
26}
27
28
29public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
30    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
31            60L, TimeUnit.SECONDS,
32            new SynchronousQueue<Runnable>(),
33            threadFactory);
34}
35
36/**
37 * 是一个单线程的Executor，它创建单个工作者线程来执行任务，如果这个线程异常结束，会创建另一个线程来代替。
38 * 能确保依照任务在队列中的顺序来串行执行。
39 */
40public static ExecutorService newSingleThreadExecutor() {
41    return new FinalizableDelegatedExecutorService
42            (new ThreadPoolExecutor(1, 1,
43                    0L, TimeUnit.MILLISECONDS,
44                    new LinkedBlockingQueue<Runnable>()));
45}
46
47public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
48    return new DelegatedScheduledExecutorService
49            (new ScheduledThreadPoolExecutor(1));
50}
51
52public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
53    return new ScheduledThreadPoolExecutor(corePoolSize);
54}
55
56/**
57 * 创建一个固定长度的线程池，而且以延迟或定时的方式来执行任务
58 */
59public static ScheduledExecutorService newScheduledThreadPool(
60        int corePoolSize, ThreadFactory threadFactory) {
61    return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
62}

3.Executor的生命周期

由于Executor以异步方式来执行任务，因此在任何时刻，之前提交任务的状态不是立即可见的。

有些任务可能应经完成，有些任务可能正在运行，而其他任务可能在队列中等待执行。

为解决执行任务的声明周期问题，Executor扩展了ExecutorService接口，添加了一些用于声明周期管理的方法。

1public interface ExecutorService extends Executor {
2
3    void shutdown();
4
5    List<Runnable> shutdownNow();
6
7    boolean isShutdown();
8
9    boolean isTerminated();
10
11    boolean awaitTermination(long timeout, TimeUnit unit)
12            throws InterruptedException;
13
14
15    <T> Future<T> submit(Callable<T> task);
16
17    <T> Future<T> submit(Runnable task, T result);
18
19    Future<?> submit(Runnable task);
20    ............
21    ............
22}

ExecutorService的声明周期有三种状态：运行、关闭和已终止。ExecutorService在初始创建时处于运行状态。

‍_shutdown_ ‍方法将执行平缓的关闭过程：不在接受新的任务，同时等待已经提交的任务执行完成---包括那些还未开始执行的任务。

‍_shutdownNow_ ‍方法将执行粗暴的关闭过程：他将尝试取消所有运行中的任务，并且不再启动队列中尚未开始执行的任务。

在ExecutorService关闭后提交的任务将由“拒绝执行处理器”来处理。

‍可以调用awaitTermination()来等待ExecutorService到达终止状态。

‍**或者通过调用isTerminated()来轮询ExecutorService是否已经终止。**‍‍

支持关闭操作的web服务器

示例代码：

1public class LifecycleWebServer {
2
3    private final ExecutorService exec = ...;
4
5    public void start() throws IOException {
6        ServerSocket serverSocket = new ServerSocket(80) ;
7
8        while (!exec.isShutdown()){
9            try {
10                final Socket conn = serverSocket.accept();
11                exec.execute(new Runnable() {
12                    @Override
13                    public void run() {
14                        handlerRequest(conn);
15                    }
16                });
17            } catch (ReflectiveOperationException e){
18                if (!exec.isShutdown()){
19                    log("task submission rejected",e);
20                }
21            }
22        }
23    }
24
25    public void stop(){
26        exec.shutdown();
27    }
28
29    public void handlerRequest(Socket conn) {
30        Request request = readRequest(conn);
31        if (isShutdownRequest(request))
32            stop();
33        else
34            dispatchRequest(request);
35    }
36}

4.延迟任务和周期任务

延迟任务：在100秒后执行该任务

周期任务：每10秒执行一次任务

Timer存在一些缺陷，应该考虑使用ScheduleThreadPoolExecutor来代替他。

可以通过‍ScheduleThreadPoolExecutor ‍的构造函数或Executors 的 newScheduleThreadPool  工厂方法来创建该类的对象。

Timer在执行所有定时任务时只会创建一个线程。如果某个任务执行时间过长，那么将破坏其他TimerTask的定时精确性。

Timer另一个问题是如果TimeTask抛出了一个未检查的异常，那么Timer将表现出槽糕的行为。Timer线程并不捕获异常，因此

当TimerTask抛出未检查的异常时将终止定时线程。这种情况下，Timer也不会恢复线程的执行，而是会错误地认为整个Timer都消失了。

因此，已经被调度但尚未执行的TimerTask将不会再执行，新的任务也不会被调度。这就是线程泄漏。

三、找出可利用的并行性

1.携带结果的任务‍‍Callable与Future‍‍

Executor框架使用Runnable作为其基本的任务表示形式。

Runnable是一种有很大局限的抽象，虽然run能写入到日志文件或者将结果放入某个共享的数据结构，但它不能返回一个值或抛出一个受检查的异常。

许多任务实际上都是存在延迟的计算。对于具有延迟性的任务，Callable是一种更好的抽象 ：它认为主入口点（即call）将返回一个值，并可能抛出一个异常。

‍_‍‍‍‍‍‍Runnable和Callable描述的都是抽象的计算任务。_‍‍

Executor执行的任务有4个生命周期阶段：创建，提交，开始，完成。

Future表示一个任务的生命周期，并提供了相应的方法来判断是否已经完成或取消，以及获取任务的结果和取消任务等。

在Future规范中包含的隐含意义是，任务的生命周期只能前进，不能后退，就像ExecutorService的生命周期一样。当某个任务完成后，它就永远停留在完成的状态上。

1public interface Future<V> {
2    boolean cancel(boolean mayInterruptIfRunning);
3    boolean isCancelled();
4    boolean isDone();
5    V get() throws InterruptedException, ExecutionException;
6    V get(long timeout, TimeUnit unit) 
7            throws InterruptedException, ExecutionException, TimeoutException; 
8}
9
10public interface Callable<V> { 
11        V call() throws Exception; 
12}

可以通过多种方式创建一个Future来描述任务。ExecutorService中的所有submit方法都将返回一个Future，从而将一个Runnable或Callable提交给Executor，并得到一个Future用来获取任务的执行结果或者取消任务。

==========END==========