02_多线程的实现方式

一、Thread类和Runnable接口

1.1、继承Thread类

package co.dianjiu.thread;

public class MyThread extends Thread{

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

    public static void main(String[] args) {
        new MyThread().start();
    }
}

问：为什么调用start方法才算启动线程？

答：在程序里面调用了start()方法后，虚拟机会先为我们创建一个线程处于就绪状态，并没有运行，然后等到这个线程第一次得到时间片时，就会调用执行run()方法，run方法运行结束，此线程终止。

1.2、实现Runnable接口

package co.dianjiu.thread;

public class MyRunnable implements Runnable{

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

    public static void main(String[] args) {
        //直接调用run方法执行
        new MyRunnable().run();
        //把自定义的实现runnable方法的类的实例丢到Thread的构造方法中，即可调用Thread类的start方法
        new Thread(new MyRunnable()).start();
        // Java 8 函数式编程，可以省略MyThread类
        new Thread(()->{
            System.out.println("匿名内部类");
        }).start();
    }
}

1.3、Thread类的常用方法

这里介绍一下Thread类的几个常用的方法：

• currentThread()：静态方法，返回对当前正在执行的线程对象的引用；
• start()：开始执行线程的方法，java虚拟机会调用线程内的run()方法；
• yield()：yield在英语里有放弃的意思，同样，这里的yield()指的是当前线程愿意让出对当前处理器的占用。这里需要注意的是，就算当前线程调用了yield()方法，程序在调度的时候，也还有可能继续运行这个线程的；
• sleep()：静态方法，使当前线程睡眠一段时间；
• join()：使当前线程等待另一个线程执行完毕之后再继续执行，内部调用的是Object类的wait方法实现的；

1.4、Thread与Runnable的比较

实现一个自定义的线程类，可以有继承Thread类或者实现Runnable接口这两种方式，它们之间有什么优劣呢？

• 由于Java“单继承，多实现”的特性，Runnable接口使用起来比Thread更灵活。
• Runnable接口出现更符合面向对象，将线程单独进行对象的封装。
• Runnable接口出现，降低了线程对象和线程任务的耦合性。
• 如果使用线程时不需要使用Thread类的诸多方法，显然使用Runnable接口更为轻量。

所以，我们通常优先使用“实现Runnable接口”这种方式来自定义线程类。

二、Callable、Future与FutureTask

JDK提供了Callable接口与Future类为我们解决这个问题，这也是所谓的“异步”模型。

2.1、Callable接口

Callable一般是配合线程池工具ExecutorService来使用的。我们会在后续章节解释线程池的使用。这里只介绍ExecutorService可以使用submit方法来让一个Callable接口执行。（由于Alibaba代码规范中提到，线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，所以我也会提供使用ThreadPoolExecutor创建线程池，然后使用submit方法来让一个callable接口执行。）它们都会返回一个Future，我们后续的程序可以通过这个Future的get方法得到结果。

package co.dianjiu.thread;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class MyCallable implements Callable {

    @Override
    public String call() throws Exception {
        return "MyCallable";
    }

    public static void main(String args[]) throws Exception {
        //ExecutorService executor = Executors.newCachedThreadPool();
        //MyCallable task = new MyCallable();
        //Future<String> result = executor.submit(task);
        // 注意调用get方法会阻塞当前线程，直到得到结果。
        // 所以实际编码中建议使用可以设置超时时间的重载get方法。
        //System.out.println(result.get());
        
        /**
         * 阿里巴巴Java开发手册中明确指出
         * 【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，
         * 这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
         * 说明：Executors各个方法的弊端：
         * 1）newFixedThreadPool和newSingleThreadExecutor:
         *   主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。
         * 2）newCachedThreadPool和newScheduledThreadPool:
         *   主要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。
         */
        ExecutorService pool = new ThreadPoolExecutor(5, 200,
                30, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(1024), new ThreadPoolExecutor.AbortPolicy());
        MyCallable task = new MyCallable();
        Future result = pool.submit(task);
        System.out.println(result.get());
    }
}

ThreadPoolExecutor参数的初步解释

使用ThreadPoolExecutor创建线程池
参数1：corePoolSize 核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
参数2：maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
参数3：keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
参数4：unit：参数keepAliveTime的时间单位，有7种取值。TimeUnit.DAYS、TimeUnit.HOURS、TimeUnit.MINUTES、TimeUnit.SECONDS、TimeUnit.MILLISECONDS、TimeUnit.MICROSECONDS、TimeUnit.NANOSECONDS
参数5：workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue。ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。
参数6：threadFactory：线程工厂，主要用来创建线程**(上面和下面都省略了这个参数)**
参数7：handler：表示当拒绝处理任务时的策略，有以下四种取值：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

2.2、Future接口

package java.util.concurrent;


public interface Future<V> {
    /**
     * 尝试取消执行此任务。 如果任务已经完成，已经被取消或由于某些其他原因而无法取消，则此尝试将失败。 
     * 如果成功，并且在调用cancel时此任务尚未开始，则此任务永远不会运行。 
     * 如果任务已经启动，则mayInterruptIfRunning参数确定是否应中断执行该任务的线程以尝试停止该任务。
     * 此方法返回后，对isDone后续调用将始终返回true 。 
     * 对后续调用isCancelled总是返回true ，如果这个方法返回true 。
     * 参数：mayInterruptIfRunning –如果应该中断执行此任务的线程，则为true否则为true 。 
     * 否则，正在进行的任务将被允许完成
     * 返回值：如果无法取消任务，则返回false ，通常是因为它已经正常完成了； 否则为true
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     *如果此任务在正常完成之前被取消，则返回true
     */
    boolean isCancelled();

    /**
     * 如果此任务完成，则返回true 。
     * 完成可能是由于正常终止，异常或取消引起的，在所有这些情况下，此方法都将返回true 。
     */
    boolean isDone();

    /**
     * 必要时等待计算完成，然后检索其结果。
     * 返回值：计算结果
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     * 必要时最多等待给定时间以完成计算，然后检索其结果（如果有）。
     * 参数：超时–等待的最长时间 unit –超时参数的时间单位
     * 返回值：计算结果
     */
    V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
}

2.3、FutureTask类

package co.dianjiu.thread;

import java.util.concurrent.*;

public class MyFutureTask implements Callable {

    @Override
    public String call() throws Exception {
        return "MyFutureTask";
    }

    public static void main(String args[]) throws Exception {
        //ExecutorService executor = Executors.newCachedThreadPool();
        //FutureTask<String> futureTask = new FutureTask<>(new MyFutureTask());
        //executor.submit(futureTask);
        //System.out.println(futureTask.get());
        
        /**
         * 阿里巴巴Java开发手册中明确指出
         * 【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，
         * 这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
         * 说明：Executors各个方法的弊端：
         * 1）newFixedThreadPool和newSingleThreadExecutor:
         * 主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。
         * 2）newCachedThreadPool和newScheduledThreadPool:
         * 主要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。
         */
        ExecutorService pool = new ThreadPoolExecutor(5, 200,
                30, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(1024), new ThreadPoolExecutor.AbortPolicy());
        FutureTask<String> futureTask = new FutureTask<>(new MyFutureTask());
        pool.submit(futureTask);
        System.out.println(futureTask.get());
    }
}

一起跟一下源码

由上图FutureTask UML 类图可知，FutureTask是实现的RunnableFuture接口的，而RunnableFuture接口同时继承了Runnable接口和Future接口。所以JDK提供了一个FutureTask类实现了Future中cancel，get，isDone等方法来供我们使用。

2.4、FutureTask的几个状态

此任务的运行状态，最初为NEW。 运行状态仅在set，setException和cancel方法中转换为终端状态。 在完成期间，状态可能会采用COMPLETING（正在设置结果时）或INTERRUPTING（仅在中断跑步者满足cancel（true）时）的瞬态值。 从这些中间状态到最终状态的转换使用便宜的有序/惰性写入，因为值是唯一的，无法进一步修改。 可能的状态转换：新->完成->正常新->完成->例外新->取消新->中断->中断

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;