多线程和并发——读《编写高质量代码：改善Java程序的151个建议》（九）

读书，收获，分享
建议后面的五角星仅代表笔者个人需要注意的程度。
Talk is cheap.Show me the code

建议118：不推荐覆写start方法★★★☆☆

错误的多线程应用示例：

class MultiThread extends Thread{
    @Override
    public synchronized void start() {
        //调用线程体        
        run();
    }
    @Override
    public void run() {
        //MultiThread do someThing
    }
}

public static void main(String[] args) {
        //多线程对象
        MultiThread m = new MultiThread();
        //启动多线程
        m.start();
}
    /**
     * main方法根本就没有启动一个子线程，整个应用程序中只有一个主线程在运行，并不会创建任何其它的线程。
     * 对此，有很简单的解决办法。只要删除MultiThread类的start方法即可。
     * */

要说明这个问题，就需要看一下Thread类的源代码了。Thread类的start方法的代码（JDK7版本的）如下：

public synchronized void start() {
        // 判断线程状态，必须是未启动状态
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        // 加入线程组中
        group.add(this);
        boolean started = false;
        try {
            // 分配栈内存，启动线程，运行run方法
            start0();
            started = true;
        } finally {
            try {
                //启动失败，从线程组中移除当前线程
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
              
            }
        }
    }　　　
    // 本地方法
     private native void start0();

这里的关键是本地方法start0，它实现了启动线程、申请栈内存、运行run方法、修改线程状态等职责，线程管理和栈内存管理都是由JVM负责的，如果覆盖了start方法，也就是撤消了线程管理和栈内存管理的能力。

如果确实有必要覆写start方法，那该如何处理呢？只要在start方法中加上super.start即可：

class MultiThread extends Thread {
    @Override
    public synchronized void start() {
        /* 线程启动前的业务处理 */
        super.start();
        /* 线程启动后的业务处理 */
    }

    @Override
    public void run() {
        // MultiThread do someThing
    }

}

注意：继承自Thread类的多线程类不必覆写start方法。

建议119：启动线程前stop方法是不可靠的☆☆☆☆☆

stop方法，是一个已弃用的方法且设计实现有一定的缺陷，要避免使用。详细说明

建议120：不使用stop方法停止线程★★☆☆☆

因为它有以下三个问题：

1. stop方法是过时的

   从Java编码规则来说，已经过时的方法不建议采用。

2. stop方法会导致代码逻辑不完整

   stop方法是一种“恶意”的中断，一旦执行stop方法，即终止当前正在运行的线程，不管线程逻辑是否完整，这是非常危险的。看如下的代码：

       public static void main(String[] args) {
           //子线程
           Thread thread = new Thread() {
               @Override
               public void run() {
                   try {
                       // 子线程休眠1秒
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       // 异常处理
                   }
                   System.out.println("此处代码不会执行");
               }
           };
           // 启动线程
           thread.start();
           // 主线程休眠0.1秒
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           // 子线程停止
           thread.stop();
       }
   

   这段代码的的逻辑：

   1. 子线程是一个匿名内部类，它的run方法在执行时会休眠1秒钟，然后再执行后续的逻辑。
   2. 主线程则是休眠0.1秒后终止子线程的运行。
   3. 也就是说，JVM在执行thread.stop()时，子线程还在执行sleep(1000)。
   4. 此时stop方法会清除栈内信息，结束该线程。
   5. 因为stop线程了，println这些就都不再执行，这也就导致了run方法的逻辑不完整。
   6. 而且此种操作也是非常隐蔽的，子线程执行到何处会被关闭很难定位，这为以后的维护带来了很多麻烦。

3. stop方法会破坏原子逻辑

   多线程为了解决共享资源抢占的问题，使用了锁概念，避免资源不同步，但是正因此原因，stop方法却会带来更大的麻烦：它会丢弃所有的锁，导致原子逻辑受损。例如有这样一段程序：

      
       /**
        * 其中run方法中加上了synchronized代码块，表示内部是原子逻辑，它会先自增然后再自减少
        */
    class MultiThread implements Runnable {
           int a = 0;
           @Override
           public void run() {
               // 同步代码块，保证原子操作
               synchronized ("") {
                   // 自增
                   a++;
                   try {
                       //线程休眠0.1秒
                       Thread.sleep(100);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   // 自减
                   a--;
                   String tn = Thread.currentThread().getName();
                   System.out.println(tn + ":a = " + a);
               }
           }
       }
   
    
       public static void main(String[] args) {
           MultiThread t = new MultiThread();
           Thread t1 = new Thread(t);
           // 启动t1线程
           t1.start();
           for (int i = 0; i < 5; i++) {
               new Thread(t).start();
           }
           //停止t1线程
           t1.stop();
       }
   

   此段代码的执行顺序如下：

   1. 线程t1启动，并执行run方法，由于没有其他线程持同步代码块的锁，所以t1线程执行自加后执行到sleep方法即开始休眠，此时a=1。
   2. JVM又启动了5个线程，也同时运行run方法，由于synchronized关键字的阻塞作用，这5个线程不能执行自增和自减操作，等待t1线程锁释放。
   3. 主线程执行了t1.stop方法，终止了t1线程，注意，由于a变量是所有线程共享的，所以其他5个线程获得的a变量也是1。
   4. 其他5个线程依次获得CPU执行机会，打印出a值。

   原本期望synchronized同步代码块中的逻辑都是原子逻辑，不受外界线程的干扰，但是结果却出现原子逻辑被破坏的情况，这也是stop方法被废弃的一个重要原因：破坏了原子逻辑。

那怎样才能终止一个正在运行的线程呢？使用自定义的标志位决定线程的执行情况，代码如下：

class SafeStopThread extends Thread {
    // 此变量必须加上volatile
    private volatile boolean stop = false;

    @Override
    public void run() {
        // 判断线程体是否运行
        while (stop) {
            // doSomething
        }
    }

    public void terminate() {
        stop = true;
    }
}

volatile：

1. 作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值。
2. 被设计用来修饰被不同线程访问和修改的变量。
3. 如果不加入volatile，基本上会导致这样的结果：要么无法编写多线程程序，要么编译器失去大量优化的机会。

Thread还提供了interrupt方法，作用：修改中断标志。虽然名字看上去很像是终止一个线程的方法，但它不是。

public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                // 线程一直运行
                while (true) {
                    System.out.println("Running......");
                }
            }
        };
        // 启动线程
        thread.start();
        // 中断线程
        thread.interrupt();
    }
//　执行这段代码，你会发现一直有Running在输出，永远不会停止。

如果需要终止该线程，还需要自行进行判断，如下才是正确使用方式：

class SafeStopThread extends Thread {
    @Override
    public void run() {
        //判断线程体是否运行
        while (!isInterrupted()) {
            // do SomeThing
        }
    }
}

如果我们使用的是线程池（比如ThreadPoolExecutor类），那么可以通过shutdown方法逐步关闭池中的线程，它采用的是比较温和、安全的关闭线程方法，完全不会产生类似stop方法的弊端。

建议121：线程优先级只使用三个等级★★☆☆☆

线程的优先级（Priority）决定了线程获得CPU运行的机会，优先级越高获得的运行机会越大，优先级越低获得的机会越小。Java的线程有10个级别（准确地说是11个级别，级别为0的线程是JVM的，应用程序不能设置该级别）。

但是在测试过程中会有如下两个现象（不管多少次）：

1. 并不是严格遵照线程优先级别来执行的

   比如：线程优先级为9的线程可能比优先级为10的线程先执行，优先级为1的线程可能比优先级为2的线程先执行，但很少会出现优先级为2的线程比优先级为10的线程先执行（这里用了一个词“很少”，是说确实有可能出现，只是几率非常低，因为优先级只是表示线程获得CPU运行的机会，并不代表强制的排序号）。

2. 优先级差别越大，运行机会差别越明显

   比如：优先级为10的线程通常会比优先级为2的线程先执行，但是优先级为6的线程和优先级为5的线程差别就不太明显了，执行多次，你会发现有不同的顺序。

为什么呢？因为线程运行是需要获得CPU资源的。

那谁能决定哪个线程先获得哪个线程后获得呢？这是依照操作系统设定的线程优先级来分配的，也就是说，每个线程要运行，需要操作系统分配优先级和CPU资源。

对于Java来说，JVM调用操作系统的接口设置优先级，比如Windows操作系统是通过调用SetThreadPriority函数来设置的。

不同的操作系统线程优先级都相同吗？是不相同的。Windows有7个优先级，Linux有140个优先级.........

Java是跨平台的系统，需要把这个10个优先级映射成不同操作系统的优先级，于是界定了Java的优先级只是代表抢占CPU的机会大小，优先级越高，抢占CPU的机会越大，被优先执行的可能性越高，优先级相差不大，则抢占`CPU的机会差别也不大，这就是导致了优先级为9的线程可能比优先级为10的线程先运行。

于是在Thread类中设置了三个优先级常量：

public class Thread implements Runnable {
    /**
     * 最低优先级
     */
    public final static int MIN_PRIORITY = 1;
    /**
     * 普通优先级，默认值
     */
    public final static int NORM_PRIORITY = 5;
    /**
     * 最高优先级
     */
    public final static int MAX_PRIORITY = 10;

}

如果优先级相同呢？也是由操作系统决定的，基本上是按照FIFO原则（先入先出，First Input First Output），但也是不能完全保证。

注意：线程优先级推荐使用MIN_PRIORITY、NORM_PRIORITY、MAX_PRIORITY三个级别，不建议使用其他7个数字。

建议122：使用线程异常处理器提升系统可靠性★★☆☆☆

Java 1.5版本以后在Thread类中增加了setUncaughtExceptionHandler方法，实现了线程异常的捕捉和处理。

异常处理器应用的例子，代码如下：

class TcpServer implements Runnable {
    // 创建后即运行
    public TcpServer() {
        Thread t = new Thread(this);
        t.setUncaughtExceptionHandler(new TcpServerExceptionHandler());
        t.start();
    }
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            try {
                Thread.sleep(1000);
                System.out.println("系统正常运行:" + i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 抛出异常
        throw new RuntimeException();
    }

    // 异常处理器
    private static class TcpServerExceptionHandler implements
            Thread.UncaughtExceptionHandler {

        @Override
        public void uncaughtException(Thread t, Throwable e) {
            // 记录线程异常信息
            System.out.println("线程" + t.getName() + " 出现异常,自行重启，请分析原因。");
            e.printStackTrace();
            // 重启线程，保证业务不中断
            new TcpServer();
        }

    }
    
        public static void main(String[] args) {
            TcpServer tcpServer =new TcpServer();
        }
}

代码的逻辑：

1. 在TcpServer类创建时即启动一个线程，提供TCP服务，具体逻辑在run方法中实现。
2. 同时，设置了该线程出现运行期异常（也就是UncaughtException）时，由TcpServerExceptionHandler异常处理器来处理。
3. TcpServerExceptionHandler异常处理器做什么事呢？两件事：
   1. 记录异常信息，以便查找问题。
   2. 重新启动一个新线程，提供不间断的服务。

运行结果如下：

系统正常运行:0
系统正常运行:1
系统正常运行:2
线程Thread-0 出现异常,自行重启，请分析原因。
java.lang.RuntimeException
    at com.jyswm.demo1.t151.TcpServer.run(TcpServer.java:22)
    at java.lang.Thread.run(Thread.java:745)
系统正常运行:0
系统正常运行:1
系统正常运行:2
线程Thread-1 出现异常,自行重启，请分析原因。
java.lang.RuntimeException
    at com.jyswm.demo1.t151.TcpServer.run(TcpServer.java:22)
    at java.lang.Thread.run(Thread.java:745)
系统正常运行:0
系统正常运行:1
系统正常运行:2
线程Thread-2 出现异常,自行重启，请分析原因。
java.lang.RuntimeException
    at com.jyswm.demo1.t151.TcpServer.run(TcpServer.java:22)
    at java.lang.Thread.run(Thread.java:745)
系统正常运行:0
系统正常运行:1
系统正常运行:2
线程Thread-3 出现异常,自行重启，请分析原因。
java.lang.RuntimeException
    at com.jyswm.demo1.t151.TcpServer.run(TcpServer.java:22)
    at java.lang.Thread.run(Thread.java:745)

这段程序只是一个示例程序，若要在实际环境中应用，则需要注意以下三个方面：

1. 共享资源锁定

   如果线程异常产生的原因是资源被锁定，自动重启应用只会增加系统的负担，无法提供不间断服务。

   例如一个即时通信服务器（XMPP Server）出现信息不能写入的情况时，即使再怎么重启服务，也是无法解决问题的。在此情况下最好的办法是停止所有的线程，释放资源。

2. 脏数据引起系统逻辑混乱

   异常的产生中断了正在执行的业务逻辑，特别是如果正在执行一个原子操作

   （像即时通信服务器的用户验证和签到这两个事件应该在一个操作中处理，不允许出现验证成功但签到不成功的情况），但如果此时抛出了运行期异常就有可能会破坏正常的业务逻辑，例如出现用户认证通过了，但签到不成功的情况，在这种情景下重启应用服务器，虽然可以提供服务，但对部分用户则产生了逻辑异常。

3. 内存溢出

   线程异常了，但由该线程创建的对象并不会马上回收，如果再重新启动新线程，再创建一批新对象，特别是加入了场景接管，就非常危险了。

   例如即时通信服务，重新启动一个新线程必须保证原在线用户的透明性，即用户不会察觉服务重启，在此种情况下，就需要在线程初始化时加载大量对象以保证用户的状态信息，但是如果线程反复重启，很可能会引起OutOfMemory内存泄露问题。

建议123：volatile不能保证数据同步★★☆☆☆

每个线程都运行在栈内存中，每个线程都有自己的工作内存（Working Memory，比如寄存器Register、高速缓冲存储器Cache等），线程的计算一般是通过工作内存进行交互的，其示意图下所示：

从示意图可以看出：

1. 线程在初始化时从主内存中加载所需的变量值到工作内存中。
2. 在线程运行时，如果是读取，则直接从工作内存中读取。
3. 若是写入则先写到工作内存中，之后再刷新到主存中。

这是JVM的一个简单的内存模型，但是这样的结构在多线程的情况下有可能会出现问题。比如：A线程修改变量的值，也刷新到了主存中，但B、C线程在此时间内读取的还是本线程的工作内存，也就是说它们读取的不是最“新鲜”的值，此时就出现了不同线程持有的公共资源不同步的情况。

对于上述这种情况有很多解决办法，比如使用synchronized同步代码块，或者使用Lock锁来解决该问题。

但使用volatile可以更简单地解决此类问题，比如在一个变量前加上volatile关键字，可以确保每个线程对本地变量的访问和修改都是直接与主内存交互的，而不是与本线程的工作内存交互的，保证每个线程都能获得最“新鲜”的变量值。示意图如下：

那么问题来了，volatile变量是否能够保证数据的同步性呢？两个线程同时修改一个volatile是否会产生脏数据呢？

volatile关键字并不能保证线程安全，它只能保证当线程需要该变量的值时能够获得最新的值，而不能保证多个线程修改的安全性。

注意：volatile不能保证数据是同步的，只能保证线程能够获得最新值。

建议124：异步运算考虑使用Callable接口★★☆☆☆

多线程应用有三种实现方式：

1. 实现Runnable接口，缺点：run方法没有返回值，不能抛出异常。
2. 继承Thread类，缺点：run方法没有返回值，不能抛出异常。（Thread也是实现了Runnable接口）
3. 实现Callable接口，具有返回值，并可抛出异常。

Callable的接口定义如下：

public interface Callable {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

实现Callable接口的类，只是表明它是一个可调用的任务，并不表示它具有多线程运算能力，还是需要执行器来执行的。代码如下：

//税款计算器
class TaxCalculator implements Callable {
    // 本金
    private int seedMoney;

    // 接收主线程提供的参数
    public TaxCalculator(int _seedMoney) {
        seedMoney = _seedMoney;
    }

    @Override
    public Integer call() throws Exception {
        // 复杂计算,运行一次需要2秒
        TimeUnit.MILLISECONDS.sleep(2000);
        return seedMoney / 10;
    }
}

这里模拟了一个复杂运算：税款计算器，该运算可能要花费10秒钟的时间，此时不能让用户一直等着吧，需要给用户输出点什么，让用户知道系统还在运行，这也是系统友好性的体现：用户输入即有输出，若耗时较长，则显示运算进度。如果我们直接计算，就只有一个main线程，是不可能有友好提示的，如果税金不计算完毕，也不会执行后续动作，所以此时最好的办法就是重启一个线程来运算，让main线程做进度提示，代码如下：

public static void main(String[] args) throws InterruptedException,
            ExecutionException {
        // 生成一个单线程的异步执行器
        ExecutorService es = Executors.newSingleThreadExecutor();
        // 线程执行后的期望值
        Future future = es.submit(new TaxCalculator(100));
        while (!future.isDone()) {
            // 还没有运算完成，等待200毫秒
            TimeUnit.MICROSECONDS.sleep(200);
            // 输出进度符号
            System.out.print("#");
        }
        System.out.println("\n计算完成，税金是：" + future.get() + "  元 ");
        es.shutdown();
    }

在该段代码中，Executors是一个静态工具类，提供了异步执行器的创建能力，如单线程执行器newSingleThreadExecutor、固定线程数量的执行器newFixedThreadPool等，一般它是异步计算的入口类。Future关注的是线程执行后的结果，比如有没有运行完毕，执行结果是多少等。

此段代码的运行结果如下所示：

##############################################
计算完成，税金是：10  元

执行时，“#”会依次递增，表示系统正在运算，为用户提供了运算进度。

此类异步计算的好处是：

• 尽可能多地占用系统资源，提供快速运算。
• 可以监控线程执行的情况，比如是否执行完毕、是否有返回值、是否有异常等。
• 可以为用户提供更好的支持，比如例子中的运算进度等。

建议125：优先选择线程池★★☆☆☆

一个线程有五个状态：新建状态（New）、可运行状态（Runnable，也叫做运行状态）、阻塞状态（Blocked）、等待状态（Waiting）、结束状态（Terminated），线程的状态只能由新建转变为了运行态后才可能被阻塞或等待，最后终结，不可能产生本末倒置的情况，比如想把一个结束状态的线程转变为新建状态，则会出现异常（IllegalThreadStateException）。

一个线程的运行时间分为三部分：T1为线程启动时间，T2为线程体的运行时间，T3为线程销毁时间。

如果一个线程不能被重复使用，每次创建一个线程都需要经过启动、运行、销毁这三个过程，那么这势必会增大系统的响应时间。有没有更好的办法降低线程的运行时间呢？

T2是无法避免的，只有通过优化代码来实现降低运行时间。T1和T2都可以通过线程池（ThreadPool）来缩减时间，比如在容器（或系统）启动时，创建足够多的线程，当容器（或系统）需要时直接从线程池中获得线程，运算出结果，再把线程返回到线程池中—ExecutorService就是实现了线程池的执行器，示例如下：

public static void main(String[] args) throws InterruptedException {
        // 2个线程的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        // 多次执行线程体
        for (int i = 0; i < 4; i++) {
            es.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        // 关闭执行器
        es.shutdown();
    }

运行结果：

pool-1-thread-1
pool-1-thread-2
pool-1-thread-1
pool-1-thread-2

按照之前阐述的“一个线程不可能从结束状态转变为可运行状态”，那为什么此处的2个线程可以反复使用呢？此处就是我们要搞清楚的重点。

线程池的实现涉及以下三个名词：

1. 工作线程（Worker）

   线程池中的线程，只有两个状态：可运行状态和等待状态，在没有任务时它们处于等待状态，运行时可以循环地执行任务。

2. 任务接口（Task）

   这是每个任务必须实现的接口，以供工作线程调度器调度，它主要规定了任务的入口、任务执行完的场景处理、任务的执行状态等。

   这里有两种类型的任务：具有返回值（或异常）的Callable接口任务和无返回值并兼容旧版本的Runnable接口任务。

3. 任务队列（Wok Queue）

   也叫做工作队列，用于存放等待处理的任务，一般是BlockingQueue的实现类，用来实现任务的排队处理。

Executors.newFixedThreadPool(2)表示创建一个具有2个线程的线程池，源代码如下：

public class Executors {
    //生成一个最大为nThreads的线程池执行器
  public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
    }

}
//这里使用了LinkedBlockingQueue作为任务队列管理器，
//所有等待处理的任务都会放在该队列中，需要注意的是，此队列是一个阻塞式的单端队列。

线程池建立好了，那就需要线程在其中运行了，线程池中的线程是在submit第一次提交任务时建立的，代码如下：

public Future submit(Runnable task) {
        //检查任务是否为null
        if (task == null) throw new NullPointerException();
        //把Runnable任务包装成具有返回值的任务对象，不过此时并没有执行，只是包装
        RunnableFuture