java笔试要点（java多线程）

一.线程的生命周期及五种基本状态

关于Java中线程的生命周期，首先看一下下面这张较为经典的图：

上图中基本上囊括了Java中多线程各重要知识点。掌握了上图中的各知识点，Java中的多线程也就基本上掌握了。主要包括：

Java线程具有五中基本状态

新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

二. Java多线程的创建及启动

Java中线程的创建常见有如三种基本形式

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

 1 class MyThread extends Thread {

 2

 3     private int i = 0;

 4

 5     @Override

 6     public void run() {

 7         for (i = 0; i < 100; i++) {

 8             System.out.println(Thread.currentThread().getName() + " " + i);

 9         }

10     }

11 }

 1 public class ThreadTest {

 2

 3     public static void main(String[] args) {

 4         for (int i = 0; i < 100; i++) {

 5             System.out.println(Thread.currentThread().getName() + " " + i);

 6             if (i == 30) {

 7                 Thread myThread1 = new MyThread();     // 创建一个新的线程  myThread1  此线程进入新建状态

 8                 Thread myThread2 = new MyThread();     // 创建一个新的线程 myThread2 此线程进入新建状态

 9                 myThread1.start();                     // 调用start()方法使得线程进入就绪状态

10                 myThread2.start();                     // 调用start()方法使得线程进入就绪状态

11             }

12         }

13     }

14 }

如上所示，继承Thread类，通过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体代表了线程需要完成的任务，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。

2.实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。

 1 class MyRunnable implements Runnable {

 2     private int i = 0;

 3

 4     @Override

 5     public void run() {

 6         for (i = 0; i < 100; i++) {

 7             System.out.println(Thread.currentThread().getName() + " " + i);

 8         }

 9     }

10 }

 1 public class ThreadTest {

 2

 3     public static void main(String[] args) {

 4         for (int i = 0; i < 100; i++) {

 5             System.out.println(Thread.currentThread().getName() + " " + i);

 6             if (i == 30) {

 7                 Runnable myRunnable = new MyRunnable(); // 创建一个Runnable实现类的对象

 8                 Thread thread1 = new Thread(myRunnable); // 将myRunnable作为Thread target创建新的线程

 9                 Thread thread2 = new Thread(myRunnable);

10                 thread1.start(); // 调用start()方法使得线程进入就绪状态

11                 thread2.start();

12             }

13         }

14     }

15 }

相信以上两种创建新线程的方式大家都很熟悉了，那么Thread和Runnable之间到底是什么关系呢？我们首先来看一下下面这个例子。

 1 public class ThreadTest {

 2

 3     public static void main(String[] args) {

 4         for (int i = 0; i < 100; i++) {

 5             System.out.println(Thread.currentThread().getName() + " " + i);

 6             if (i == 30) {

 7                 Runnable myRunnable = new MyRunnable();

 8                 Thread thread = new MyThread(myRunnable);

 9                    thread.start();

10             }

11         }

12     }

13 }

14

15 class MyRunnable implements Runnable {

16     private int i = 0;

17

18     @Override

19     public void run() {

20         System.out.println("in MyRunnable run");

21         for (i = 0; i < 100; i++) {

22             System.out.println(Thread.currentThread().getName() + " " + i);

23         }

24     }

25 }

26

27 class MyThread extends Thread {

28

29     private int i = 0;

30

31     public MyThread(Runnable runnable){

32         super(runnable);

33     }

34

35     @Override

36     public void run() {

37         System.out.println("in MyThread run");

38         for (i = 0; i < 100; i++) {

39             System.out.println(Thread.currentThread().getName() + " " + i);

40         }

41     }

42 }

同样的，与实现Runnable接口创建线程方式相似，不同的地方在于

1 Thread thread = new MyThread(myRunnable);

那么这种方式可以顺利创建出一个新的线程么？答案是肯定的。至于此时的线程执行体到底是MyRunnable接口中的run()方法还是MyThread类中的run()方法呢？通过输出我们知道线程执行体是MyThread类中的run()方法。其实原因很简单，因为Thread类本身也是实现了Runnable接口，而run()方法最先是在Runnable接口中定义的方法。

1 public interface Runnable {

2

3     public abstract void run();

4

5 }

我们看一下Thread类中对Runnable接口中run()方法的实现：

　　@Override

    public void run() {

        if (target != null) {

            target.run();

        }

    }

也就是说，当执行到Thread类中的run()方法时，会首先判断target是否存在，存在则执行target中的run()方法，也就是实现了Runnable接口并重写了run()方法的类中的run()方法。但是上述给到的列子中，由于多态的存在，根本就没有执行到Thread类中的run()方法，而是直接先执行了运行时类型即MyThread类中的run()方法。（作者这些提到的多态，其实是指这里调用的是MyThread类的run方法，并没有调用super.run()）

3.使用Callable和Future接口创建线程。具体是创建Callable接口的实现类，并实现call()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。

看着好像有点复杂，直接来看一个例子就清晰了。

 1 public class ThreadTest {

 2

 3     public static void main(String[] args) {

 4

 5         Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象

 6         FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象

 7

 8         for (int i = 0; i < 100; i++) {

 9             System.out.println(Thread.currentThread().getName() + " " + i);

10             if (i == 30) {

11                 Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程

12                 thread.start();                      //线程进入到就绪状态

13             }

14         }

15

16         System.out.println("主线程for循环执行完毕..");

17

18         try {

19             int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果

20             System.out.println("sum = " + sum);

21         } catch (InterruptedException e) {

22             e.printStackTrace();

23         } catch (ExecutionException e) {

24             e.printStackTrace();

25         }

26

27     }

28 }

29

30

31 class MyCallable implements Callable<Integer> {

32     private int i = 0;

33

34     // 与run()方法不同的是，call()方法具有返回值

35     @Override

36     public Integer call() {

37         int sum = 0;

38         for (; i < 100; i++) {

39             System.out.println(Thread.currentThread().getName() + " " + i);

40             sum += i;

41         }

42         return sum;

43     }

44

45 }

首先，我们发现，在实现Callable接口中，此时不再是run()方法了，而是call()方法，此call()方法作为线程执行体，同时还具有返回值！在创建新的线程时，是通过FutureTask来包装MyCallable对象，同时作为了Thread对象的target。那么看下FutureTask类的定义：

1 public class FutureTask<V> implements RunnableFuture<V> {

2

3     //....

4

5 }

1 public interface RunnableFuture<V> extends Runnable, Future<V> {

2

3     void run();

4

5 }

于是，我们发现FutureTask类实际上是同时实现了Runnable和Future接口，由此才使得其具有Future和Runnable双重特性。通过Runnable特性，可以作为Thread对象的target，而Future特性，使得其可以取得新创建线程中的call()方法的返回值。

执行下此程序，我们发现sum = 4950永远都是最后输出的。而“主线程for循环执行完毕..”则很可能是在子线程循环中间输出。由CPU的线程调度机制，我们知道，“主线程for循环执行完毕..”的输出时机是没有任何问题的，那么为什么sum =4950会永远最后输出呢？

原因在于通过ft.get()方法获取子线程call()方法的返回值时，当子线程此方法还未执行完毕，ft.get()方法会一直阻塞，直到call()方法执行完毕才能取到返回值。

上述主要讲解了三种常见的线程创建方式，对于线程的启动而言，都是调用线程对象的start()方法，需要特别注意的是：不能对同一线程对象两次调用start()方法。

三. Java多线程的就绪、运行和死亡状态

就绪状态转换为运行状态：当此线程得到处理器资源；

运行状态转换为就绪状态：当此线程主动调用yield()方法或在运行过程中失去处理器资源。

运行状态转换为死亡状态：当此线程线程执行体执行完毕或发生了异常。

此处需要特别注意的是：当调用线程的yield()方法时，线程从运行状态转换为就绪状态，但接下来CPU调度就绪状态中的哪个线程具有一定的随机性，因此，可能会出现A线程调用了yield()方法后，接下来CPU仍然调度了A线程的情况。

由于实际的业务需要，常常会遇到需要在特定时机终止某一线程的运行，使其进入到死亡状态。目前最通用的做法是设置一boolean型的变量，当条件满足时，使线程执行体快速执行完毕。如：

 1 public class ThreadTest {

 2

 3     public static void main(String[] args) {

 4

 5         MyRunnable myRunnable = new MyRunnable();

 6         Thread thread = new Thread(myRunnable);

 7

 8         for (int i = 0; i < 100; i++) {

 9             System.out.println(Thread.currentThread().getName() + " " + i);

10             if (i == 30) {

11                 thread.start();

12             }

13             if(i == 40){

14                 myRunnable.stopThread();

15             }

16         }

17     }

18 }

19

20 class MyRunnable implements Runnable {

21

22     private boolean stop;

23

24     @Override

25     public void run() {

26         for (int i = 0; i < 100 && !stop; i++) {

27             System.out.println(Thread.currentThread().getName() + " " + i);

28         }

29     }

30

31     public void stopThread() {

32         this.stop = true;

33     }

34

35 }

作者关于停止一个线程的描述有些模糊。

我另外找到的比较完整的解释如下：

与此问题相关的内容主要涉及三部分：已废弃的Thread.stop()、迷惑的thread.interrupt系列、最佳实践Shared Variable。

已废弃的Thread.stop()

@Deprecated

public final void stop() {

    stop(new ThreadDeath());

}

如上是Hotspot JDK 7中的java.lang.Thread.stop()的代码，学习一下它的doc：

该方法天生是不安全的。使用thread.stop()停止一个线程，导致释放（解锁）所有该线程已经锁定的监视器（因沿堆栈向上传播的未检查异常ThreadDeath而解锁）。如果之前受这些监视器保护的任何对象处于不一致状态，则不一致状态的对象（受损对象）将对其他线程可见，这可能导致任意的行为。

是不是差点被这段话绕晕，俗点说：目标线程可能持有一个监视器，假设这个监视器控制着某两个值之间的逻辑关系，如var1必须小于var2，某一时刻var1等于var2，本来应该受保护的逻辑关系，不幸的是此时恰好收到一个stop命令，产生一个ThreadDeath错误，监视器被解锁。这就导致逻辑错误，当然这种情况也可能不会发生，是不可预料的。注意：ThreadDeath是何方神圣？是个java.lang.Error，不是java.lang.Exception。

public class ThreadDeath extends Error {

    private static final long serialVersionUID = -4417128565033088268L;

}

thread.stop()方法的许多应用应该由“只修改某些变量以指示目标线程应该停止”的代码取代。目标线程应周期性的检查该变量，当发现该变量指示其要停止运行，则退出run方法。如果目标线程等待很长时间，则应该使用interrupt方法中断该等待。

其实这里已经暗示停止一个线程的最佳方法：条件变量或条件变量+中断。

其它关于stop方法的doc：

该方法强迫停止一个线程，并抛出一个新创建的ThreadDeath对象作为异常。

停止一个尚未启动的线程是允许的，如果稍后启动该线程，它会立即终止。

通常不应试图捕获ThreadDeath，除非它必须执行某些异常的清除操作。如果catch子句捕获了一个ThreadDeath对象，则必须重新抛出该对象，这样该线程才会真正终止。

小结：
Thread.stop()不安全，已不再建议使用。

令人迷惑的thread.interrupt()

Thread类中有三个方法会令新手迷惑，他们是：

public void Thread.interrupt() // 无返回值

public boolean Thread.isInterrupted() // 有返回值

public static boolean Thread.interrupted() // 静态，有返回值

如果按照近几年流行的重构，代码整洁之道，程序员修炼之道等书的观点，这几个方法的命名相对于其实现的功能来说，不够直观明确，极易令人混淆，是低级程序猿的代码。逐个分析：

public void interrupt() {

    if (this != Thread.currentThread())

        checkAccess();

    synchronized (blockerLock) {

        Interruptible b = blocker;

        if (b != null) {

            interrupt0();        // Just to set the interrupt flag

            b.interrupt(this);

            return;

        }

    }

    interrupt0();

}

中断本线程。无返回值。具体作用分以下几种情况：

如果该线程正阻塞于Object类的wait()、wait(long)、wait(long, int)方法，或者Thread类的join()、join(long)、join(long, int)、sleep(long)、sleep(long, int)方法，则该线程的中断状态将被清除，并收到一个java.lang.InterruptedException。
如果该线程正阻塞于interruptible channel上的I/O操作，则该通道将被关闭，同时该线程的中断状态被设置，并收到一个java.nio.channels.ClosedByInterruptException。
如果该线程正阻塞于一个java.nio.channels.Selector操作，则该线程的中断状态被设置，它将立即从选择操作返回，并可能带有一个非零值，就好像调用java.nio.channels.Selector.wakeup()方法一样。
如果上述条件都不成立，则该线程的中断状态将被设置。

小结：第一种情况最为特殊，阻塞于wait/join/sleep的线程，中断状态会被清除掉，同时收到著名的InterruptedException；而其他情况中断状态都被设置，并不一定收到异常。

中断一个不处于活动状态的线程不会有任何作用。如果是其他线程在中断该线程，则java.lang.Thread.checkAccess()方法就会被调用，这可能抛出java.lang.SecurityException。

public static boolean interrupted() {

    return currentThread().isInterrupted(true);

}

检测当前线程是否已经中断，是则返回true，否则false，并清除中断状态。换言之，如果该方法被连续调用两次，第二次必将返回false，除非在第一次与第二次的瞬间线程再次被中断。如果中断调用时线程已经不处于活动状态，则返回false。

public boolean isInterrupted() {

    return isInterrupted(false);

}

检测当前线程是否已经中断，是则返回true，否则false。中断状态不受该方法的影响。如果中断调用时线程已经不处于活动状态，则返回false。

interrupted()与isInterrupted()的唯一区别是，前者会读取并清除中断状态，后者仅读取状态。

在hotspot源码中，两者均通过调用的native方法isInterrupted(boolean)来实现，区别是参数值ClearInterrupted不同。

private native boolean isInterrupted(boolean ClearInterrupted);

经过上面的分析，三者之间的区别已经很明确，来看一个具体案例，是我在工作中看到某位架构师的代码，只给出最简单的概要结构：

public void run() {

  while(!Thread.currentThread().isInterrupted()) {

      try {

           Thread.sleep(10000L);

           ... //为篇幅，省略其它io操作

           ... //为简单，省略其它interrupt操作

      } catch (InterruptedException e) { break; }

  }

}

我最初被这段代码直接绕晕，用thread.isInterrupted()方法作为循环中止条件可以吗？

根据上文的分析，当该方法阻塞于wait/join/sleep时，中断状态会被清除掉，同时收到InterruptedException，也就是接收到的值为false。上述代码中，当sleep之后的调用otherDomain.xxx()，otherDomain中的代码包含wait/join/sleep并且InterruptedException被catch掉的时候，线程无法正确的中断。

因此，在编写多线程代码的时候，任何时候捕获到InterruptedException，要么继续上抛，要么重置中断状态，这是最安全的做法，参考『Java Concurrency in Practice』。凡事没有绝对，如果你可以确保一定没有这种情况发生，这个代码也是可以的。

下段内容引自：『Java并发编程实战』第5章基础构建模块 5.4 阻塞方法与中断方法 p77

当某个方法抛出InterruptedException时，表示该方法是一个阻塞方法。当在代码中调用一个将抛出InterruptedException异常的方法时，你自己的方法也就变成了一个阻塞方法，并且必须要处理对中断的相应。对于库代码来说，有两种选择：

传递InterruptedException。这是最明智的策略，将异常传递给方法的调用者。
恢复中断。在不能上抛的情况下，如Runnable方法，必须捕获InterruptedException，并通过当前线程的interrupt()方法恢复中断状态，这样在调用栈中更高层的代码将看到引发了一个中断。如下代码是模板：

public void run() {

    try {

          // ① 调用阻塞方法

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();    // ② 恢复被中断的状态

        }

}

最后再强调一遍，②处的 Thread.currentThread().interrupt() 非常非常重要。

最佳实践：Shared Variable

不记得哪本书上曾曰过，最佳实践是个烂词。在这里这个词最能表达意思，停止一个线程最好的做法就是利用共享的条件变量。

对于本问题，我认为准确的说法是：停止一个线程的最佳方法是让它执行完毕，没有办法立即停止一个线程，但你可以控制何时或什么条件下让他执行完毕。

通过条件变量控制线程的执行，线程内部检查变量状态，外部改变变量值可控制停止执行。为保证线程间的即时通信，需要使用使用volatile关键字或锁，确保读线程与写线程间变量状态一致。下面给一个最佳模板：

/**

 * @author bruce_sha (bruce-sha.github.io)

 * @version 2013-12-23

 */

public class BestPractice extends Thread {

    private volatile boolean finished = false;   // ① volatile条件变量

    public void stopMe() {

        finished = true;    // ② 发出停止信号

    }

    @Override

    public void run() {

        while (!finished) {    // ③ 检测条件变量

            // do dirty work   // ④业务代码

        }

    }

}

当④处的代码阻塞于wait()或sleep()时，线程不能立刻检测到条件变量。因此②处的代码最好同时调用interrupt()方法。

小结：
How to Stop a Thread or a Task ? 详细讨论了如何停止一个线程, 总结起来有三点：

使用violate boolean变量来标识线程是否停止。
停止线程时，需要调用停止线程的interrupt()方法，因为线程有可能在wait()或sleep(), 提高停止线程的即时性。
对于blocking IO的处理，尽量使用InterruptibleChannel来代替blocking IO。

总结：

要使任务和线程能安全、快速、可靠地停止下来，并不是一件容易的事。Java没有提供任何机制来安全地终止线程。但它提供了中断（Interruption），这是一种协作机制，能够使一个线程终止另一个线程的的工作。—— 『Java并发编程实战』第7章取消与关闭 p111

中断是一种协作机制。一个线程不能强制其它线程停止正在执行的操作而去执行其它的操作。当线程A中断B时，A仅仅是要求B在执行到某个可以暂停的地方停止正在执行的操作——前提是如果线程B愿意停下来。—— 『Java并发编程实战』第5章基础构建模块 p77

总之，中断只是一种协作机制，需要被中断的线程自己处理中断。停止一个线程最佳实践是中断 + 条件变量。