谁不会休息，谁就不会工作。 — 列宁

写在前面

Android沿用了Java的线程模型，一个Android应用创建的时候就会开启一个线程，我们叫它主线程或者UI线程，如果想要访问网络或数据库等耗时操作时，就会开启一个子线程去处理。从Android3.0开始，系统规定网络访问必须在子线程中进行，否则会抛出异常。就是为了避免因耗时操作阻塞主线程从而发生ANR，也证明了多线程在Android应用开发中占据着十分重要的位置。

进程和线程

在了解线程之前，我们先来了解一下进程，什么是进程？进程是操作系统结构的基础，是程序在一个数据集合上运行的过程，是系统资源分配和调度的基本单元，进程可以被看做是程序的实体，进程也是线程的容器。这么说过于抽象，下面打开我们电脑的任务管理器：

任务管理器.png

从图片中可以看到“应用”下面包含三个前台进程，“后台进程”有五十七个，每一个进程就对应一个应用。

上面图片中"WeChat(32)位"对应微信这个应用的进程，这个进程里又运行了许多子任务，有的处理缓存，有的进行下载，有的接收消息，这些子任务就是线程，是操作系统调度的最小单元，也叫做轻量级的进程。一个进程可以创建多个线程，可以创建的线程数量取决于操作系统，每个线程都拥有各自的计数器，堆栈和局部变量等属性，并且能够访问共享的内存数据。

为何使用多线程

从操作系统级别上来看主要有以下四个方面：

• 使用多线程能够减少程序响应的时间。如果某个操作耗时，或是陷入长时间的等待，就不能响应鼠标或键盘等操作，使用多线程能够将耗时操作放到一个单独的线程中执行，从而使程序具备了更好的交互性。
• 与进程相比，线程的创建和切换开销更小，在访问共享数据方面效率非常高。
• 多CPU或多核计算机本身就具备执行多线程的能力。如果执行单个线程，就无法重复利用计算机的资源，从而导致巨大的资源被浪费，在多CPU的计算机中使用多线程能够有效提升CPU的利用率。
• 使用多线程能够简化程序结构，使程序便于理解和维护。

线程的状态

Java线程在运行的生命周期中会有六种不同的状态：

• New：新创建状态。线程创建，但还没有调用start函数，线程运行之前还有一些基础工作要做。
• Runnable：可运行状态。一旦调用start函数，线程就处于可运行状态，可运行状态的线程可能正在运行也可能没有运行，这取决于操作系统给线程提供运行的时间。
• Blocked：阻塞状态。表示线程被锁阻塞，暂不活动。
• Waiting：等待状态。表示线程暂不活动，并且不运行任何的代码，直到线程调度器重新激活它。
• Timed Waiting：超时等待状态。与等待状态不同，超时等待状态的线程会在指定的时间自行返回。
• Terminated：终止状态。表示线程执行完毕，终止线程有两种情况，第一种是线程的run函数执行完毕正常退出，第二种情况是因为一个没有捕获的异常而终止了run函数，导致线程进入终止状态。

线程的状态.png

从上图可以看到新创建状态(NEW)调用start()函数进入到可运行状态(RUNNABLE)。调用wait()等函数使可运行状态(RUNNABLE)的线程进入到等待状态(WAITING)，调用notify()等函数使等待状态(WAITING)的线程回到可运行状态(RANNABLE)。超时等待状态(TIMED WAITING)就是在等待状态(WAITING)的基础上加入了时间的限制，达到指定的时间线程会从超时等待状态(TIMED WAITING)自行回到可运行状态(RUNNABLE)。调用同步方法时，线程获取不到锁就会进入阻塞状态(BLOCKED)，直到线程再次获取到锁才会从阻塞状态(BLOCKED)回到可运行状态(RUNNABLE)。直到run()函数执行完毕或发生异常意外终止，线程才会变为终止状态(TERMINATED)。

创建线程

多线程的实现方法一般有三种，其中前两种为最常用的方法。

1.继承Thread类，重写run()方法

Thread类本质上是实现了Runnable接口的一个实现类，需要注意的是调用了start()方法不会立即执行多线程的代码，而是让该线程变为可运行状态，什么时候运行多线程的代码是由操作系统决定的。

实现步骤：

• 定义一个Thread的子类，并重写run()方法，该run()方法的方法体就代表了该线程要完成的任务，因此，run()方法被称为执行体。
• 创建Thread的子类对象，即创建了线程对象。
• 调用线程对象的start()方法来启动该线程。

    public static void main(String[] args) {
        Thread thread = new ChildThread();
        thread.start();
    }

    private static class ChildThread extends Thread {
        @Override
        public void run() {
            super.run();
            System.out.print("执行体");
        }
    }

2.实现Runnable接口，并实现该接口的run方法

实现步骤：

• 定义一个类并实现Runnable接口，实现run()方法。
• 定义Thread的子类对象，并使用实现Runnable接口的对象作为参数实例化该Thread的子类对象。
• 调用Thread的子类对象的start()方法来开启线程。

    public static void main(String[] args) {
        RunnableImpl runnable = new RunnableImpl();
        Thread thread = new Thread(runnable);
        thread.start();
    }
    
    private static class RunnableImpl implements Runnable {

        @Override
        public void run() {
            System.out.print("执行体");
        }
    } 

3.实现Callable接口，实现call()方法

Callable接口实际上是Executor框架中的功能类，Callable接口和Runnable接口功能类似，但提供了比Runnable接口更强大的功能，主要体现在以下三个方面：

• Callable接口可以在任务结束后提供一个返回值，Runnable接口无法提供这个功能。
• Callable接口中的call()方法能抛出异常，Runnable接口中的run()方法不能抛出异常。
• 运行Callable接口可以得到一个Futrue对象，Futrue对象表示异步计算的结果，它提供了检查异步计算是否完成的方法。由于线程属于异步计算模型，因此无法从其他线程得到函数的返回值，这种情况就需要Future对象监视目标线程执行call()方法的情况。但调用Futrue的get()方法以获取结果时，当前线程就会阻塞，直到call()方法返回结果。

实现步骤：

• 定义一个类实现Callable接口，并实现call()方法将计算结果作为返回值。
• 创建线程池ExecutorService，使用实现Callable接口的对象作为参数传给ExecutorService的submit(callable)来开启线程，并接收Futrue对象。
• 调用Futrue对象的get()方法获取结果。

    public static void main(String[] args) {
        CallableImpl callable = new CallableImpl();
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        
        Future future = executorService.submit(callable);

        try {
            String result = (String) future.get();
            System.out.print(result);
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static class CallableImpl implements Callable {

        @Override
        public String call() throws Exception {
            return "计算结果";
        }
    }

中断线程

当线程的run方法执行完毕，或者在方法中出现了没有捕获的异常时，线程将终止。

在Java的早期版本中提供了一个stop方法，其他线程调用stop方法就会终止线程，由于该方法会带来一些问题，现在已经被弃用了。

interrupt方法可以用来请求中断线程，一个线程调用interrupt方法就会将线程的中断标识位置为true，线程会不时的检测线程的中断标识位以判断线程是否可以被中断。要想知道线程是否可以被中断，可以调用Thread.currentThread().isInterrupted()方法。

还可以调用interrupted方法对线程的中断标识位进行复位，但是如果线程被阻塞，将无法判断中断状态。如果一个线程处于阻塞状态，线程在检测线程的中断标识位时发现线程的中断标识位为true，就会在方法调用出抛出InterruptedException异常，并且在抛出异常前将线程的中断标识位重置，即设置为false。

需要注意的是被中断的线程并不一定会终止，中断线程只是为了引起线程的注意，被中断的线程决定是否响应中断。如果是非常重要的线程则不理会中断，但大部分情况是线程将中断作为一个终止的请求。另外，不要在底层代码中捕获InterruptedException异常后不做处理。如下：

    private static class ChildThread extends Thread {
        @Override
        public void run() {
            super.run();
            try {
                sleep(500);
            } catch (InterruptedException e) {
                // do something
            }
        }
    }

推荐两种捕获InterruptedException异常后正确的处理方式：

• 第一种方式

    public static void main(String[] args) {
        Thread thread = new ChildThread();
        // 开启子线程
        thread.start();
        // 让当前线程阻塞20毫秒
        TimeUnit.MILLISECONDS.sleep(20);
        // 设置线程的中断标识位为true
        thread.interrupt();
    }

    private static class ChildThread extends Thread {
        @Override
        public void run() {
            super.run();
            doing();
        }

        private void doing() {
            // 让子线程阻塞500毫秒，500毫秒之内如果调用了子线程的interrupt方法，
            // 就会抛出InterruptedException异常，在方法内部直接捕获。
            try {
                sleep(500);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

• 第二种方式

    public static void main(String[] args) {
        Thread thread = new ChildThread();
        // 开启子线程
        thread.start();
        // 让当前线程阻塞20毫秒
        TimeUnit.MILLISECONDS.sleep(20);
        // 设置线程的中断标识位为true
        thread.interrupt();
    }

    private static class ChildThread extends Thread {
        @Override
        public void run() {
            super.run();
            // 调用者捕获InterruptedException异常
            try {
                doing();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        private void doing() throws InterruptedException{
            // 让子线程阻塞500毫秒，500毫秒之内如果调用了子线程的interrupt方法，
            // 就会抛出InterruptedException异常，将异常向外抛出。
           sleep(500);
        }
    }

由于抛出InterruptedException异常之前会将线程的中断标识位复位，即设置为false，所以在catch语句中再调用一次Thread.currentThread().interrupt()方法将线程的中断标识位设置为true，这样外部再次调用Thread.currentThread().isInterrupted()方法时就知道线程应该被中断了。

安全的中断线程

在前面了解到了如何中断线程，现在就来看看如何安全的中断线程，这里介绍两种安全的中断线程的方式。

• 第一种方式

    public static void main(String[] args) {
        Thread thread = new ChildThread();
        // 开启子线程
        thread.start();
        // 让当前线程阻塞500毫秒
        TimeUnit.MILLISECONDS.sleep(500);
        // 设置线程的中断标识位为true
        thread.interrupt();
    }

    private static class ChildThread extends Thread {
        @Override
        public void run() {
            super.run();
            // 判断线程的中断标识位是否为中断状态，
            // 如果没有被中断则会一直调用doing，否则会被中断
            while (!Thread.currentThread().isInterrupted()) {
                doing();
            }
        }

        private void doing() {
            System.out.print("执行任务");
        }
    }

• 第二种方式

    public static void main(String[] args) {
        ChildThread thread = new ChildThread();
        // 开启子线程
        thread.start();
        // 让当前线程阻塞500毫秒
        TimeUnit.MILLISECONDS.sleep(500);
        // 设置线程的中断标识位为true
        thread.cancel();
    }

    private static class ChildThread extends Thread {

        private volatile boolean isCancel;

        @Override
        public void run() {
            super.run();
            // 判断isCancel标识位是否为true，
            // 如果isCancel标识位不为true则会一直调用doing，否则会被中断
            while (!isCancel) {
                doing();
            }
        }

        private void doing() {
            System.out.print("执行任务");
        }

        public void cancel() {
            isCancel = true;
        }
    }

其实以上两种方式的原理相同，都是通过一个标识位来判断当前线程是否应该被中断。

总结

虽然线程的stop方法被弃用了，但是却有中断线程这种替代方案。线程的中断标识位只不过是一个普通的标识位，开发者可以根据线程的中断标识位来决定是否应该中断线程，可以根据实际的项目需求使用线程的中断标识位，如果是非常重要的线程则不理会即可。但是对于一个处于阻塞状态的线程，若线程在检测线程的中断标识位时发现线程的中断标识位为true时，抛出的InterruptedException异常被捕获后一定要做处理。