`

JAVA面试题解惑系列（十）——话说多线程

多线程Java面试thread虚拟机
阅读更多

关键字: java 面试题 多线程 thread 线程池 synchronized 死锁

作者：臧圩人（zangweiren） 
网址：http://zangweiren.iteye.com 

>>>转载请注明出处！<<< 

线程或者说多线程，是我们处理多任务的强大工具。线程和进程是不同的，每个进程都是一个独立运行的程序，拥有自己的变量，且不同进程间的变量不能 共享；而线程是运行在进程内部的，每个正在运行的进程至少有一个线程，而且不同的线程之间可以在进程范围内共享数据。也就是说进程有自己独立的存储空间， 而线程是和它所属的进程内的其他线程共享一个存储空间。线程的使用可以使我们能够并行地处理一些事情。线程通过并行的处理给用户带来更好的使用体验，比如 你使用的邮件系统（outlook、Thunderbird、foxmail等），你当然不希望它们在收取新邮件的时候，导致你连已经收下来的邮件都无法 阅读，而只能等待收取邮件操作执行完毕。这正是线程的意义所在。 

实现线程的方式 

实现线程的方式有两种： 
  1. 继承java.lang.Thread，并重写它的run()方法，将线程的执行主体放入其中。
  2. 实现java.lang.Runnable接口，实现它的run()方法，并将线程的执行主体放入其中。

这是继承Thread类实现线程的示例： 
Java代码 复制代码
  1. public class ThreadTest extends Thread {  
  2.     public void run() {  
  3.         // 在这里编写线程执行的主体  
  4.         // do something  
  5.     }  
  6. }  
Java代码 
  1. public class ThreadTest extends Thread {  
  2.     public void run() {  
  3.         // 在这里编写线程执行的主体  
  4.         // do something  
  5.     }  
  6. }  

这是实现Runnable接口实现多线程的示例： 
Java代码 复制代码
  1. public class RunnableTest implements Runnable {  
  2.     public void run() {  
  3.         // 在这里编写线程执行的主体  
  4.         // do something  
  5.     }  
  6. }  
Java代码 
  1. public class RunnableTest implements Runnable {  
  2.     public void run() {  
  3.         // 在这里编写线程执行的主体  
  4.         // do something  
  5.     }  
  6. }  

这两种实现方式的区别并不大。继承Thread类的方式实现起来较为简单，但是继承它的类就不能再继承别的类了，因此也就不能继承别的类的有用的 方法了。而使用是想Runnable接口的方式就不存在这个问题了，而且这种实现方式将线程主体和线程对象本身分离开来，逻辑上也较为清晰，所以推荐大家 更多地采用这种方式。 

如何启动线程 

我们通过以上两种方式实现了一个线程之后，线程的实例并没有被创建，因此它们也并没有被运行。我们要启动一个线程，必须调用方法来启动它，这个方 法就是Thread类的start()方法，而不是run()方法（既不是我们继承Thread类重写的run()方法，也不是实现Runnable接口 的run()方法）。run()方法中包含的是线程的主体，也就是这个线程被启动后将要运行的代码，它跟线程的启动没有任何关系。上面两种实现线程的方式 在启动时会有所不同。 

继承Thread类的启动方式： 
Java代码 复制代码
  1. public class ThreadStartTest {  
  2.     public static void main(String[] args) {  
  3.         // 创建一个线程实例  
  4.         ThreadTest tt = new ThreadTest();  
  5.         // 启动线程  
  6.         tt.start();  
  7.     }  
  8. }  
Java代码 
  1. public class ThreadStartTest {  
  2.     public static void main(String[] args) {  
  3.         // 创建一个线程实例  
  4.         ThreadTest tt = new ThreadTest();  
  5.         // 启动线程  
  6.         tt.start();  
  7.     }  
  8. }  

实现Runnable接口的启动方式： 
Java代码 复制代码
  1. public class RunnableStartTest {  
  2.     public static void main(String[] args) {  
  3.         // 创建一个线程实例  
  4.         Thread t = new Thread(new RunnableTest());  
  5.         // 启动线程  
  6.         t.start();  
  7.     }  
  8. }  
Java代码 
  1. public class RunnableStartTest {  
  2.     public static void main(String[] args) {  
  3.         // 创建一个线程实例  
  4.         Thread t = new Thread(new RunnableTest());  
  5.         // 启动线程  
  6.         t.start();  
  7.     }  
  8. }  

实际上这两种启动线程的方式原理是一样的。首先都是调用本地方法启动一个线程，其次是在这个线程里执行目标对象的run()方法。那么这个目标对象是什么呢？为了弄明白这个问题，我们来看看Thread类的run()方法的实现： 
Java代码 复制代码
  1. public void run() {  
  2.     if (target != null) {  
  3.         target.run();  
  4.     }  
  5. }  
Java代码 
  1. public void run() {  
  2.     if (target != null) {  
  3.         target.run();  
  4.     }  
  5. }  

当我们采用实现Runnable接口的方式来实现线程的情况下，在调用new Thread(Runnable target)构造器时，将实现Runnable接口的类的实例设置成了线程要执行的主体所属的目标对象target，当线程启动时，这个实例的 run()方法就被执行了。当我们采用继承Thread的方式实现线程时，线程的这个run()方法被重写了，所以当线程启动时，执行的是这个对象自身的 run()方法。总结起来就一句话，线程类有一个Runnable类型的target属性，它是线程启动后要执行的run()方法所属的主体，如果我们采 用的是继承Thread类的方式，那么这个target就是线程对象自身，如果我们采用的是实现Runnable接口的方式，那么这个target就是实 现了Runnable接口的类的实例。 

线程的状态 

在Java 1.4及以下的版本中，每个线程都具有新建、可运行、阻塞、死亡四种状态，但是在Java 5.0及以上版本中，线程的状态被扩充为新建、可运行、阻塞、等待、定时等待、死亡六种。线程的状态完全包含了一个线程从新建到运行，最后到结束的整个生 命周期。线程状态的具体信息如下： 
  1. NEW（新建状态、初始化状态）：线程对象已经被创建，但是还没有被启动时的状态。这段时间就是在我们调用new命令之后，调用start()方法之前。
  2. RUNNABLE（可运行状态、就绪状态）：在我们调用了线程的start()方法之后线程所处的状态。处于RUNNABLE状态的线程在JAVA虚拟机（JVM）上是运行着的，但是它可能还正在等待操作系统分配给它相应的运行资源以得以运行。
  3. BLOCKED（阻塞状态、被中断运行）：线程正在等待其它的线程释放同步锁，以进入一个同步块或者同步方法继续运行；或者它已经进入了某个同步块或同步方法，在运行的过程中它调用了某个对象继承自java.lang.Object的wait()方法，正在等待重新返回这个同步块或同步方法。
  4. WAITING（等待状态）：当前线程调用了java.lang.Object.wait()、 java.lang.Thread.join()或者java.util.concurrent.locks.LockSupport.park()三个 中的任意一个方法，正在等待另外一个线程执行某个操作。比如一个线程调用了某个对象的wait()方法，正在等待其它线程调用这个对象的notify() 或者notifyAll()（这两个方法同样是继承自Object类）方法来唤醒它；或者一个线程调用了另一个线程的join()（这个方法属于 Thread类）方法，正在等待这个方法运行结束。
  5. TIMED_WAITING（定时等待状态）：当前线程调用了 java.lang.Object.wait(long timeout)、java.lang.Thread.join(long millis)、java.util.concurrent.locks.LockSupport.packNanos(long nanos)、java.util.concurrent.locks.LockSupport.packUntil(long deadline)四个方法中的任意一个，进入等待状态，但是与WAITING状态不同的是，它有一个最大等待时间，即使等待的条件仍然没有满足，只要到 了这个时间它就会自动醒来。
  6. TERMINATED（死亡状态、终止状态）：线程完成执行后的状态。线程执行完run()方法中的全部代码，从该方法中退出，进入TERMINATED状态。还有一种情况是run()在运行过程中抛出了一个异常，而这个异常没有被程序捕获，导致这个线程异常终止进入TERMINATED状态。

在Java5.0及以上版本中，线程的全部六种状态都以枚举类型的形式定义在java.lang.Thread类中了，代码如下： 
Java代码 复制代码
  1. public enum State {  
  2.     NEW,  
  3.     RUNNABLE,  
  4.     BLOCKED,  
  5.     WAITING,  
  6.     TIMED_WAITING,  
  7.     TERMINATED;  
  8. }  
Java代码 
  1. public enum State {  
  2.     NEW,  
  3.     RUNNABLE,  
  4.     BLOCKED,  
  5.     WAITING,  
  6.     TIMED_WAITING,  
  7.     TERMINATED;  
  8. }  

sleep()和wait()的区别 

sleep()方法和wait()方法都成产生让当前运行的线程停止运行的效果，这是它们的共同点。下面我们来详细说说它们的不同之处。 

sleep()方法是本地方法，属于Thread类，它有两种定义： 
Java代码 复制代码
  1. public static native void sleep(long millis) throws InterruptedException;  
  2.   
  3. public static void sleep(long millis, int nanos) throws InterruptedException {  
  4.     //other code  
  5. }  
Java代码 
  1. public static native void sleep(long millis) throws InterruptedException;  
  2.   
  3. public static void sleep(long millis, int nanos) throws InterruptedException {  
  4.     //other code  
  5. }  

其中的参数millis代表毫秒数（千分之一秒），nanos代表纳秒数（十亿分之一秒）。这两个方法都可以让调用它的线程沉睡（停止运行）指定 的时间，到了这个时间，线程就会自动醒来，变为可运行状态（RUNNABLE），但这并不表示它马上就会被运行，因为线程调度机制恢复线程的运行也需要时 间。调用sleep()方法并不会让线程释放它所持有的同步锁；而且在这期间它也不会阻碍其它线程的运行。上面的连个方法都声明抛出一个 InterruptedException类型的异常，这是因为线程在sleep()期间，有可能被持有它的引用的其它线程调用它的 interrupt()方法而中断。中断一个线程会导致一个InterruptedException异常的产生，如果你的程序不捕获这个异常，线程就会 异常终止，进入TERMINATED状态，如果你的程序捕获了这个异常，那么程序就会继续执行catch语句块（可能还有finally语句块）以及以后 的代码。 

为了更好地理解interrupt()效果，我们来看一下下面这个例子： 
Java代码 复制代码
  1. public class InterruptTest {  
  2.     public static void main(String[] args) {  
  3.         Thread t = new Thread() {  
  4.             public void run() {  
  5.                 try {  
  6.                     System.out.println("我被执行了-在sleep()方法前");  
  7.                     // 停止运行10分钟  
  8.                     Thread.sleep(1000 * 60 * 60 * 10);  
  9.                     System.out.println("我被执行了-在sleep()方法后");  
  10. border-left: #d1d7dc 1px solid; padding-bottom: 0px; line-height: 18px; background-color: #fafafa; margin: 0px 0px 0px 38px; padding-left: 10px; padding-right: 0px; fo
    分享到：
    | 多线程相关的知识点
    评论
    发表评论

    您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics