7.2.1 创建和启动线程
在java.lang包中，有一个Thread类用来代表线程对象，Thread类也是进行多线程编程时主要面对的类。java.lang包中的类不需引入便可以在程序中直接使用。
本节介绍如何利用Thread类进行基本的线程编程：创建和启动线程。
7.2.1.1 获取当前线程对象
首先明确一点，线程不是在代码中显式地创建之后才存在，而是当应用程序启动之后便有一个默认存在的线程，这个线程可以称之为主线程。无论对于主线程，还是主线程创建的子线程，都可以通过Thread类的currentThread()方法来获取当前线程对象，currentThread()方法是Thread类的静态方法，这意味着无须创建Thread对象便可以调用该方法。在获取线程对象之后，可以通过Thread类的getId()方法获取该线程在整个Java虚拟机中唯一的标识。
以下的代码行先获取当前的线程对象，继而获取当前线程对象的标识：
System.out.println(Thread.currentThread().getId());
线程ID是一个正的长整型数，在创建该线程时生成。线程ID是唯一的，并在线程的生命周期内保持不变。线程被终止后，该线程ID可以被重新分配给其他的线程。
7.2.1.2 线程命名
线程的名称可以在创建线程时指定，如果创建线程时没有指定任何名称，Java虚拟机会以“Thread-序号”的规则为线程命名，例如“Thread-0”。主线程默认以“main”为线程的名称。线程的名称可以通过Thread类的getName()方法获得。
无论线程处于何种运行状态，均可以调用Thread类的setName()方法改变线程名称。主线程的名称也可以被改变。
以下的代码片段先打印主线程的名称，然后将其改变为“MyThread”：
System.out.println("线程的原名称是："+Thread.currentThread().getName());
Thread.currentThread().setName("MyThread");
System.out.println("线程的新名称是："+Thread.currentThread().getName());
运行效果如下：
线程的原名称是：main
线程的新名称是：MyThread
7.2.1.3 构造和启动线程
构造线程对象是通过Thread类的构造方法完成的。Thread类的构造方法分为3类：独立构造方法、根据java.lang.Runnable对象的构造方法、根据线程组的构造方法。后面两类构造方法稍后介绍，下面介绍Thread类的独立构造方法：
— Thread()：构造一个线程，线程名由Java虚拟机根据线程命名规则指定。
— Thread(String name)：构造一个线程，以name为线程名。
下面代码片段构造了两个线程，其中thread1由Java虚拟机根据线程命名规则指定，thread2命名为“MyThread”：
Thread thread1=new Thread();
Thread thread2=new Thread("MyThread");
以上构建的线程都是没有任何运行逻辑的，也就是线程体为空。线程的线程体包含在Thread类的run()方法中，可以在构建线程对象时重载run()方法，写入自定义的逻辑。构建线程之后启动线程的方法是利用Thread类的start()方法。对Thread类的run()和start()方法说明如下。
— void run()：本方法中的逻辑为线程体。如果在构建线程时没有重载run()方法，则线程体为空；如果线程系根据传入的java.lang.Runnable对象而构建，则以该Runnable对象的run()方法为线程体。
— void start()：启动线程，开始执行线程对象的run()方法。
以下的代码片段构建了thread1、thread2、thread3共3个线程对象，其中thread3重载了run()方法，在线程体中打印出“线程3开始运行...”字样。然后分别启动3个线程，因为thread1和thread2的线程体均为空，所以没有任何运行效果。接下来打印3个线程的标识和名称：
Thread thread1=new Thread();
Thread thread2=new Thread("MyThread");
Thread thread3=new Thread()
{
public void run()
{
System.out.println("线程3开始运行...");
}
};
thread1.start();
thread2.start();
thread3.start();
System.out.println("线程1的ID是："+thread1.getId());
System.out.println("线程2的ID是："+thread2.getId());
System.out.println("线程3的ID是："+thread3.getId());
System.out.println("线程1的名称是："+thread1.getName());
System.out.println("线程2的名称是："+thread2.getName());
System.out.println("线程3的名称是："+thread3.getName());
运行效果如下，线程的标识由Java虚拟机分配，最终运行效果可能有所不同：
线程1的ID是：8
线程2的ID是：9
线程3的ID是：10
线程1的名称是：Thread-0
线程2的名称是：MyThread
线程3的名称是：Thread-1
线程3开始运行...
7.2.1.4 线程优先级
为了区分一个线程对于操作系统和用户的重要性，Java定义了线程的优先级策略，优先级高的处于就绪状态的线程更有机会获得CPU时间片。
Java将线程的优先级分为10个等级，分别用1~10之间的数字表示。数字越大表明线程的优先级别越高。相应地，在Thread类中定义了表示线程最低、最高和普通优先级的成员变量MIN_PRIORITY、MAX_PRIORITY和NORMAL_PRIORITY，代表的优先级等级分别为1、10和5。当一个线程对象被创建时，其默认的线程优先级是5。
为了控制线程的运行策略，Java定义了线程调度器来监控系统中处于就绪状态的所有线程。线程调度器按照线程的优先级决定哪个线程获得CPU时间片。在多个线程处于就绪状态的条件下，具有高优先级的线程会在低优先级线程之前得到执行。线程调度器采用“抢占式”策略来调度线程执行，即当前线程执行过程中有较高优先级的线程进入就绪状态，则高优先级的线程立即被调度执行。具有相同优先级的所有线程采用轮转的方式来共同分配CPU时间片。
在应用程序中设置线程优先级的方法很简单，在创建线程对象之后可以调用线程对象的setPriority()方法改变该线程的运行优先级，同样可以调用getPriority()方法获取当前线程的优先级。
下面的代码片段创建了两个优先级分别为10和1的两个线程，它们的任务均是在线程体中打印出问候语：
Thread thread1=new Thread("thread1")
{
public void run()
{
for(int i=0;i<5;i++)
System.out.println("Thread1 says hello to you.");
}
};
Thread thread2=new Thread("thread2")
{
public void run()
{
for(int i=0;i<5;i++)
System.out.println("Thread2 says hello to you.");
}
};
thread1.setPriority(10);
thread2.setPriority(1);
thread1.start();
thread2.start();
从以下的运行效果可以看出，thread1拥有比thread2更高的线程优先级，因此在取得CPU时间片方面更有特权，thread2几乎只有等到thread1完全执行完才被执行：
Thread1 says hello to you.
Thread1 says hello to you.
Thread1 says hello to you.
Thread1 says hello to you.
Thread1 says hello to you.
Thread2 says hello to you.
Thread2 says hello to you.
Thread2 says hello to you.
Thread2 says hello to you.
Thread2 says hello to you.
读者们可以将thread1和thread2的优先级颠倒过来，使得thread2拥有更高的优先权，然后再观察运行效果。
7.2.1.5 守护线程
在Java中有一类被称为守护（Daemon）线程的，比较特殊的线程，这是一种优先级比较低的线程。守护线程具有最低的优先级，一般用于为系统中的其他对象和线程提供服务。将一个线程设置为守护线程的方式是在线程对象创建之前调用线程对象的setDaemon()方法。典型的守护线程例子是Java虚拟机中的垃圾自动回收线程，它始终在低级别的状态中运行，用于实时监控和管理系统中的可回收资源。可以通过调用线程对象的isDaemon()方法来判断某个线程是否是守护线程。
守护线程还有另一层含义：当创建守护线程的父线程终止时，作为子线程的守护线程也自动终止。反之，如果一个子线程不是守护线程，即使父线程终止了，它也不会终止。
当一个线程被创建时，它默认不是守护线程。
下面的代码片段演示守护线程的用法。线程parent创建了一个子线程child，子线程child的循环体是一个无限循环，不断地打印“Child runs”字样。在child线程不是守护线程的情况下，即使parent线程终止了，child线程仍然在运行：
Thread parent=new Thread()
{
public void run()
{
System.out.println("Parent starts");
Thread child=new Thread()
{
public void run()
{
System.out.println("Child starts");
while(true)
{
System.out.println("Child runs");
}
}
};
child.setDaemon(false);
child.start();
System.out.println("Parent ends");
}
};
parent.start();
如果希望父线程终止时，子线程自动终止，只需要将“child.setDaemon(false);”改为“child.setDaemon(true);”即可。
7.2.2 Runnable接口和Thread基类
在上一节中，我们通过演练创建和启动线程已经熟悉了Thread类的主要方法。但是在实际的应用开发中，却往往不是通过在代码中设置内部类的方法来创建线程的，推荐采用的方式是：
— 将实现java.lang.Runnable接口的对象实例传递给java.lan.Thread类的构造方法。
— 专门设计一个类继承java.lang.Thread类。
7.2.2.1 实现Runnable接口
java.lang.Runnable接口只定义了一个方法：public void run()，当实现该接口的对象被传递给java.lan.Thread类的构造方法时，该对象所实现的run()方法将成为新线程的线程体。
通过实现Runnable接口来构造线程体，进而构造线程对象的做法的突出优点是可以实现“单实例、多线程”。即当多个Thread对象是根据实现Runnable接口的对象来构造时，实现Runnable接口的对象实例只有一份，但是在这个对象上却运行着多个线程。
如果说多线程开发对开发人员的能力提出较高的要求，那么编写单实例、多线程模式的多线程应用，则对开发人员的能力提出更高的要求，因为承载了多个线程的单实例，在面临并发时，其内部变量可能产生变量安全的问题。由于多线程并发而引起的变量安全问题，在下一章中专门介绍。
有过Servlet开发经验的读者们应该知道，如果一个Servlet实现了javax.servlet.SingleThreadModel接口，则意味着该Servlet是一个单线程Servlet，每当请求该Servlet时，Web容器都将创建出一个新的Servlet实例来响应。这样做的效率虽然略低一点，但是却能避免发生变量安全问题，因为单线程Servlet中的所有变量都是独占的，不存在并发访问的问题。
根据实现了Runnable接口的对象来创建线程的Thread类的构造方法如下。
— Thread(Runnable target)：根据target对象来创建线程，以target对象实现的run()方法作为线程体。线程名称由Java虚拟机指定。
— Thread(Runnable target, String name)：根据target对象来创建线程，以target对象实现的run()方法作为线程体。线程名称为name。
基于Runnable接口创建新线程的代码如下所示：
public class RunnableImpl implements Runnable
{
public void run()
{
……
}
}
public class MainClass
{
public static void main(String[] args)
{
Runnable target=new RunnableImpl();
Thread thread=new Thread(target);
thread.start();
}
}
下面的例程定义了一个实现Runnable接口的MyMultiThreadClass类。MyMultiThreadClass类有一个私有变量no，在构造方法中被赋值。MyMultiThreadClass类的任务是当线程运行时，打印5次“Hi!我是线程{no}”。
代码清单7‑1 Runnable接口的例程——MyMultiThreadClass
1. public class MyMultiThreadClass implements Runnable
2. {
3. private int no;
4.
5. public MyMultiThreadClass(int no)
6. {
7. this.no=no;
8. }
9.
10. public void run()
11. {
12. for(int i=0;i<5;i++)
13. System.out.println("\t<"+i+">Hi!我是线程"+no+"!");
14. System.out.println("\t线程"+no+"向你说再见...");
15. }
16. }
下面的例程演示如何基于Runnable对象创建新线程。在例程中创建了3个MyMultiThreadClass对象，并基于这些MyMultiThreadClass对象创建了3个线程，从而形成了一个包含3个元素的线程数组aThreadArray。主程序分别启动3个线程，然后等待其全部运行结束才退出。
关于本例程，有两点需要说明：
— 本例程所演示的场景不属于上述的“单实例、多线程”，而是属于“多实例、多线程”，因为3个线程系分别基于不同的Runnable对象而创建。
— 可以通过调用Thread类的isAlive()方法来判断线程目前是否结束。注意isAlive()只能用于判断线程目前是否终止，不能用于判断线程目前处于运行还是就绪状态。关于线程的状态，请参考第7.2.3.1节“线程的状态”。
源代码如下。
代码清单7‑2 Runnable接口的例程——UseRunnable
1. public class UseRunnable
2. {
3. public static void main(String args[])
4. {
5. MyMultiThreadClass[] aMTCArray=new MyMultiThreadClass[3];
6. Thread[] aThreadArray=new Thread[3];
7. System.out.println("使用接口Runnable的多线程程序:\n");
8. for(int i=0;i<3;i++)
9. {
10. aMTCArray[i]=new MyMultiThreadClass(i);
11. aThreadArray[i]=new Thread(aMTCArray[i]);
12. }
13. for(int i=0;i<3;i++)
14. aThreadArray[i].start();
15. WhileLoop:
16. while(true)
17. {
18. for(int i=0;i<3;i++)
19. if(aThreadArray[i].isAlive())
20. continue WhileLoop;
21. break;
22. }
23. System.out.println("\t我是main()!Bye bye...");
24. }
25. }
运行效果如下。在不同的计算机上打印出的信息的先后顺序可能不同，这是由线程执行的随机性和异步性所决定的：
使用接口Runnable的多线程程序：
<0>Hi!我是线程0!
<1>Hi!我是线程0!
<2>Hi!我是线程0!
<3>Hi!我是线程0!
<4>Hi!我是线程0!
线程0向你说再见...
<0>Hi!我是线程1!
<1>Hi!我是线程1!
<2>Hi!我是线程1!
<3>Hi!我是线程1!
<4>Hi!我是线程1!
线程1向你说再见...
<0>Hi!我是线程2!
<1>Hi!我是线程2!
<2>Hi!我是线程2!
<3>Hi!我是线程2!
<4>Hi!我是线程2!
线程2向你说再见...
我是main()!Bye bye...
7.2.2.2 继承Thread基类
我们在第7.2.1节“创建和启动线程”中创建线程的手段在本质上便是继承Thread基类并重载其run()方法。但是在代码中设置内部类，不是推荐的做法。通过设计一个专门的公用类来继承Thread类，突出的优点是可以使代码显得更为整洁。
通过继承Thread基类创建新线程的代码如下所示：
public class MyThread extends Thread
{
public void run()
{
……
}
}
public class MainClass
{
public static void main(String[] args)
{
MyThread thread=new MyThread();
thread.start();
}
}
下面我们利用继承Thread基类的办法再度实现一遍基于Runnable接口实现的相同功能。
继承Thread基类的自定义线程类MyMultiThread的源代码如下。
代码清单7‑3 Thread类的例程——MyMultiThread
1. public class MyMultiThread extends Thread
2. {
3. private int no;
4.
5. public MyMultiThread(int no)
6. {
7. this.no=no;
8. }
9.
10. public void run()
11. {
12. for(int i=0;i<5;i++)
13. System.out.println("\t<"+i+">Hi!我是线程"+no+"!");
14. System.out.println("\t线程"+no+"向你说再见...");
15. }
16. }
下面的例程创建了3个MyMultiThread对象实例，并分别启动它们，直至3个线程全部运行结束才退出主线程。
代码清单7‑4 Thread类的例程——UseThread
1. public class UseThread
2. {
3. public static void main(String args[])
4. {
5. MyMultiThread[] aThreadArray=new MyMultiThread[3];
6. System.out.println("使用接口Runnable的多线程程序:\n");
7. for(int i=0;i<3;i++)
8. {
9. aThreadArray[i]=new MyMultiThread(i);
10. }
11. for(int i=0;i<3;i++)
12. aThreadArray[i].start();
13. WhileLoop:
14. while(true)
15. {
16. for(int i=0;i<3;i++)
17. if(aThreadArray[i].isAlive())
18. continue WhileLoop;
19. break;
20. }
21. System.out.println("\t我是main()!Bye bye...");
22. }
23. }
运行效果应与基于Runnable接口实现的程序完全相同。
7.2.3 管理线程的状态
7.2.3.1 线程的状态
按照线程体在计算机系统内存中的状态不同，可以将线程分为创建、就绪、运行、休眠、挂起和死亡等类型。在不同类型的线程状态下，线程的特征如下所示。
— 创建状态：当利用new关键字创建线程对象实例后，它仅仅作为一个对象实例存在，JVM没有为其分配CPU时间片等运行资源。
— 就绪状态：对处于创建状态的线程调用Thread类的start()方法将线程的状态转换为就绪状态。这时，线程已经得到除CPU时间片之外的其他系统资源，只等JVM的线程调度器按照线程的优先级对该线程进行调度，从而使该线程拥有能够获得CPU时间片的机会。
— 运行状态：JVM的线程调度器选中处于就绪状态的线程，使其获得CPU时间片。
— 休眠状态：在线程运行过程中可以调用Thread类的sleep()方法，并在方法参数中指定线程的休眠时间将线程状态转换为休眠状态。这时，该线程在指定的休眠时间内，在不释放占用资源的情况下停止运行。时间到达后，线程重新进入运行状态。处于休眠状态的线程，可能遇上java.lang.InterruptedException异常，从而被迫停止休眠。
— 挂起状态：可以通过调用Thread类的suspend()方法将线程的状态转换为挂起状态。这时，线程将释放占用的所有资源，由JVM调度转入临时存储空间，直至应用程序调用Thread类的resume()方法恢复线程运行。
— 死亡状态：当线程体运行结束或者调用线程对象的Thread类的stop()方法后线程将终止运行，由JVM收回线程占用的资源。
以上6种状态及其之间的转换关系可以形象地用图7-1表示。
结合图7-1说明管理线程的常用方法。
— Thread类的构造方法：调用Thread类的构造方法之后，线程仅处于创建状态，并没有获得任何资源。
— Thread.start()：当成功调用Thread类的start()方法之后，线程将进入就绪状态，这时线程除没有拥有CPU时间片之外已经获得了其他所有的运行资源。当JVM线程调度器根据线程的优先级选中该线程时，该线程获得CPU时间片，正式进入运行状态。
图7-1 线程的6种状态
— Thread.yield()：当处于运行状态的线程调用Thread类的yield()方法之后，线程所拥有的CPU时间片被剥夺，重新回到就绪状态，等候JVM线程调度器的调度。
— Thread.sleep()：当处于运行状态的线程调用Thread类的sleep()方法之后，线程将在方法参数指定的时间段之内进入休眠状态，即在不释放任何运行资源的情况下停止运行。当休眠时间结束，或者捕获并响应由于Thread.interrupt()方法引起的InterruptedException异常之后，线程回到运行状态。
— Object.wait()：当处于运行状态的线程调用Object类的wait()方法之后，线程将方法参数指定的时间段之内、在保留运行状态的情况下回到就绪状态。Object类的wait()方法支持无参调用，表示一直停止运行，等待被Object.notify()方法唤醒。
— Object.notify()：如果线程不处于就绪（等待）状态，则调用Object类的notify()方法不起任何作用；否则线程将重新获得竞争CPU时间片的资格，从等待之前的状态点开始运行。
— Thread.suspend()：调用Thread类的suspend()方法，将处于运行状态的线程置为挂起状态。该方法只能和Thread.resume ()配合使用，已被禁用。
— Thread.resume()：调用Thread类的resume()方法，将处于挂起状态的线程置为运行状态。该方法只能和Thread.suspend()配合使用，已被禁用。
— Thread.stop()：终止线程，线程将释放占用的全部资源。该方法已被禁用。
— Thread.join()：结束线程，并等待方法参数指定的时间段。在等待期间，如果线程已经结束，则立刻返回。Thread.join()方法是推荐的结束线程的方法。
综上所述，Thread.suspend()、Thread.resume()、Thread.stop()方法已被禁用，因此线程的状态实际上只有5种：创建、就绪、运行、休眠和死亡。
7.2.3.2 线程的等待和唤醒
从图7‑1可知，等待状态是一种特殊的就绪状态。使线程陷入等待实际上是指暂时剥夺线程当前拥有的CPU时间片和获取CPU时间片的资格，使其返回到就绪状态。除非被唤醒，或者等待时间已满，该线程将一直等待，不会被JVM线程调度器选中并赋予CPU时间片。处于等待状态的线程一旦恢复执行，与其他处于就绪状态被线程调度器选中的线程不同，将从上次结束执行的断点处开始执行，而非从头开始。
使线程中断运行，返回就绪状态的手段是调用java.lang.Object对象的wait()方法；唤醒处于等待状态的线程的手段是调用java.lang.Object对象的notify()方法。对wait()和notify()方法说明如下。
— void wait()：使线程陷入一直等待的状态，除非被唤醒。
— void wait(long timeout)：使线程等待timeout指定的毫秒数。当等待时间已满，或者被唤醒，线程将重新被线程调度器调度。如果timeout为0，则等同于wait()。
— void wait(long timeout，int nanos)：使线程等待timeout指定的毫秒数＋nanos指定的微秒数。当等待时间已满，或者被唤醒，线程将重新被线程调度器调度。如果timeout和nanos均为0，则等同于wait()。
— void notify()：唤醒在此对象上等待的一个线程，如果在此对象上有多个线程同时在等待，则任意唤醒其中一个。
— void notifyAll()：唤醒在此对象上等待的所有线程。
在多线程环境中，任何线程都是由一个对象承载的，区别仅在于在一个对象上只承载了单个线程，还是同时承载了多个线程，也就是本章前面提到过的“多实例、多线程”和“单实例、多线程”。所谓的“多实例、多线程”是指在一个对象上承载了一个线程，“单实例、多线程”是指在一个对象上承载了多个线程。“多实例、多线程”的控制难度无疑要低于单实例、多线程”，因为后者的同一个对象会面临并发情况。截至目前，本章给出的例程都属于“多实例、多线程”的情况。
Object对象提供的wait()方法是指本对象所承载的某一个线程执行到本句的时候开始陷入等待状态；Object对象提供的notify()方法则是指唤醒本对象所承载的所有线程中的某一个；Object对象提供的notifyAll()方法则是指唤醒本对象所承载的所有线程。
为了帮助读者们正确地理解对象与线程之间的关系，本节设计了3个例程，这些例程完成相似的功能：启动3个子线程，这几个子线程均陷入等待状态，然后主线程唤醒它们。3个例程之间的区别和联系在于：
— 通过继承Thread基类的手段创建子线程。如前所述，通过继承Thread基类的手段创建的新线程，均属于“多实例、多线程”，这类线程分别由不同的对象承载，也就不存在数据共享和冲突的可能，同时导致唤醒这类线程只能采用一一唤醒的策略。
— 通过实现Runnable接口的手段创建子线程。如前所述，通过实现Runnable接口的手段创建的新线程，可以设计成“单实例、多线程”，也可以设计成“多实例、多线程”。本例程作为过渡，采取和第一个例程相似的模型，即不同的线程由不同的Runnable对象承载。
— 第3个例程采用3个子线程分别由相同的Runnable对象承载的策略，本例程也是迄今为止出现的第一个实现“单实例、多线程”场景的案例。正是因为这种新型的对象与线程间关系，为通过Object对象的notifyAll()方法一次性唤醒多个由同一对象承载的线程创造了条件。
以下是第一个例程NotifyWaitingThread的源代码。
代码清单7-5 等待和唤醒线程的例程——NotifyWaitingThread
1. public class NotifyWaitingThread
2. {
3. public static void main(String[] args) throws InterruptedException
4. {
5. MyThread[] threads=new MyThread[3];
6. for(int i=0;i<3;i++)
7. {
8. threads[i]=new MyThread();
9. threads[i].no=i;
10. threads[i].setDaemon(true);
11. threads[i].start();
12. }
13. Thread.sleep(500);
14. for(int i=0;i<3;i++)
15. {
16. synchronized(threads[i])
17. {
18. threads[i].notify();
19. }
20. }
21. }
22. }
23.
24. class MyThread extends Thread
25. {
26. public int no=0;
27.
28. public void run()
29. {
30. System.out.println("第"+this.no+"个线程开始等待5分钟");
31. try
32. {
33. synchronized(this)
34. {
35. this.wait(5*60*1000);
36. }
37. }
38. catch(InterruptedException ie)
39. {
40. ie.printStackTrace();
41. }
42. System.out.println("第"+this.no+"个线程被唤醒");
43. }
44. }
在代码中有两处比较超前：一是利用Thread.sleep()使线程开始休眠指定的时间，以便让各个子线程进入等待状态；二是synchronized同步锁的使用。关于线程休眠，在下一节即将介绍；关于同步锁，将在下一章中介绍。
在代码的第33行，线程在各自的对象上陷入等待状态。保留字“this”用来指代锁定的对象，本例程模拟的是“多实例、多线程”场景，各子线程拥有不同的承载自身的对象，因此在此处“this”指代的是线程对象本身。
在代码的第16行，主线程通过调用各个线程对象（threads[i]）的notify()方法唤醒各个子线程。注意，发出notify()动作的对象必须和被锁定的对象保持一致，否则无任何效果，这里由各个线程对象发出notify()动作。读者们可以试着将第18行的notify()改成notifyAll()方法，执行效果应该没有任何变化，因为在“多实例、多线程”场景下，在一个线程对象上陷入等待状态的只能有一个线程。
运行效果如下：
第0个线程开始等待5分钟
第1个线程开始等待5分钟
第2个线程开始等待5分钟
第0个线程被唤醒
第1个线程被唤醒
第2个线程被唤醒
以下是第二个例程NotifyWaitingThreadWithRunnable的源代码。
代码清单7‑6 等待和唤醒线程的例程——NotifyWaitingThreadWithRunnable
1. public class NotifyWaitingThreadWithRunnable
2. {
3. public static void main(String[] args) throws InterruptedException
4. {
5. Runner[] runners=new Runner[3];
6. Thread[] threads=new Thread[3];
7. for(int i=0;i<3;i++)
8. {
9. runners[i]=new Runner(i);
10. threads[i]=new Thread(runners[i]);
11. threads[i].setDaemon(true);
12. threads[i].start();
13. }
14. Thread.sleep(500);
15. for(int i=0;i<3;i++)
16. {
17. synchronized(runners[i])
18. {
19. runners[i].notify();
20. }
21. }
22. }
23. }
24.
25. class Runner implements Runnable
26. {
27. private int no=0;
28.
29. public Runner(int no)
30. {
31. this.no=no;
32. }
33.
34. public void run()
35. {
36. System.out.println("第"+this.no+"个线程开始等待5分钟");
37. try
38. {
39. synchronized(this)
40. {
41. this.wait(5*60*1000);
42. }
43. }
44. catch(InterruptedException ie)
45. {
46. ie.printStackTrace();
47. }
48. System.out.println("第"+this.no+"个线程被唤醒");
49. }
50. }
在本例程中，3个子线程基于3个不同的实现Runnable接口的Runner对象而创建。
在代码的第39行，线程在各自的对象上陷入等待状态。保留字“this”用来指代锁定的对象，本例程模拟的仍然是“多实例、多线程”场景，各子线程拥有不同的承载自身的对象，因此，在此处“this”指代的是实现Runnable接口的Runner对象。
在代码的第17行，主线程通过调用各个线程对象（runners[i]）的notify()方法唤醒各个子线程。这里由各个实现Runnable接口的Runner对象发出notify()动作。读者们可以试着将第19行的notify()改成notifyAll()方法，执行效果仍然没有任何变化。
运行效果如下：
第0个线程开始等待5分钟
第1个线程开始等待5分钟
第2个线程开始等待5分钟
第0个线程被唤醒
第1个线程被唤醒
第2个线程被唤醒
以下是第3个例程NotifyWaitingThreadWithSameRunnable的源代码。
代码清单7‑7 等待和唤醒线程的例程——NotifyWaitingThreadWithSameRunnable
1. public class NotifyWaitingThreadWithSameRunnable
2. {
3. public static void main(String[] args) throws InterruptedException
4. {
5. SameRunner runner=new SameRunner();
6. Thread[] threads=new Thread[3];
7. for(int i=0;i<3;i++)
8. {
9. threads[i]=new Thread(runner);
10. threads[i].setDaemon(true);
11. threads[i].start();
12. }
13. Thread.sleep(500);
14. synchronized(runner)
15. {
16. runner.notifyAll();
17. }
18. }
19. }
20.
21. class SameRunner implements Runnable
22. {
23. public void run()
24. {
25. System.out.println("线程开始等待5分钟");
26. try
27. {
28. synchronized(this)
29. {
30. this.wait(5*60*1000);
31. }
32. }
33. catch(InterruptedException ie)
34. {
35. ie.printStackTrace();
36. }
37. System.out.println("线程被唤醒");
38. }
39. }
在本例程中，3个子线程基于同一个实现Runnable接口的SameRunner对象而创建。
在代码的第28行，线程在各自的对象上陷入等待状态。保留字“this”用来指代锁定的对象，本例程模拟的是“单实例、多线程”场景，各子线程拥有相同的承载自身的对象，因此，在此处“this”指代的是同一个实现Runnable接口的SameRunner对象。
在代码的第14行，主线程通过调用SameRunner对象的notifyAll()方法唤醒了全部在此对象上陷入等待状态的线程。
运行效果如下：
线程开始等待5分钟
线程开始等待5分钟
线程开始等待5分钟
线程被唤醒
线程被唤醒
线程被唤醒
读者们可以试着将第16行的notifyAll()改成notify()方法，那么被唤醒的只有一个线程。因为当在同一个对象上有多个对象陷入等待状态的话，调用此对象的notify()方法只能随机地唤醒其中的一个：
线程开始等待5分钟
线程开始等待5分钟
线程开始等待5分钟
线程被唤醒
本节内容非常关键，理解本节内容的意义不仅在于掌握等待和唤醒线程的技能，更在于理解Java多线程编程中的对象与线程之间的关系，为进一步理解下一章的线程安全打下基础。
7.2.3.3 线程的休眠和中断
线程的休眠状态和就绪（包括等待）状态的不同之处在于，处于休眠状态的线程并不释放运行资源，在休眠结束之后，不用等待被JVM线程调度器再度选中，而可以直接进入运行状态。结束休眠状态有两种途径：（1）休眠时间到达后，线程重新进入运行状态；（2）处于休眠状态的线程遇上java.lang.InterruptedException异常，从而被迫停止休眠。
使当前线程进入休眠状态的手段是调用Thread类的sleep()方法，该方法是静态方法，这意味着不用指定Thread对象便可以直接使用。打断某线程的休眠状态的手段是调用该线程对象的interrupt()方法。对sleep()和interrupt()方法说明如下。
— void sleep(long timeout)：使当前线程休眠timeout指定的毫秒数。在休眠过程中，如果遇上中断，则抛出InterruptedException异常。
— void sleep(long timeout，int nanos)：使当前线程休眠timeout指定的毫秒数＋nanos指定的微秒数。在休眠过程中，如果遇上中断，则抛出InterruptedException异常。
— void interrupt()：中断线程的休眠状态。
下面的例程演示线程休眠和中断的用法。在例程中，开启一个子线程thread1，该子线程开始休眠5分钟，在此期间主线程调用thread1对象的interrupt()方法中断其休眠。源代码如下。
代码清单7‑8 休眠和中断线程的例程——InterruptSleepingThread
1. public class InterruptSleepingThread
2. {
3. public static void main(String[] args) throws InterruptedException
4. {
5. WaitingThread thread1=new WaitingThread();
6. thread1.start();
7. Thread.sleep(500);
8. synchronized(thread1)
9. {
10. thread1.interrupt();
11. }
12. }
13. }
14.
15. class WaitingThread extends Thread
16. {
17. public void run()
18. {
19. System.out.println("线程开始休眠5分钟");
20. try
21. {
22. Thread.sleep(5*60*1000);
23. }
24. catch(InterruptedException ie)
25. {
26. System.out.println("线程被中断休眠");
27. }
28. System.out.println("线程结束休眠");
29. }
30. }
请注意代码的第8行，中断某线程的休眠状态的代码需要放在锁定线程对象的同步锁中。
运行效果如下：
线程开始休眠5分钟
线程被中断休眠
线程结束休眠
7.2.3.4 线程的终止
对于终止运行中的线程，Thread类原本提供了一个停止线程的方法：stop()，但是实践证明该方法具有固有的不安全性，因此已被弃用。结合目前我们已经掌握的技能，已经能够完美地终止线程，那便是利用线程的休眠和中断机制，在子线程中有意地为调度线程（比如创建线程的主线程）安排中断机会。
下面的例程演示利用线程的休眠和中断机制来终止线程。子线程thread1计划循环
10 000次，但是在遇到主线程的中断调用之后退出循环，从而结束整个子线程。源代码如下。
代码清单7‑9 终止线程的例程——StopThread
1. public class StopThread
2. {
3. public static void main(String[] args) throws InterruptedException
4. {
5. MyThread thread1=new MyThread();
6. thread1.start();
7. Thread.sleep(5000);
8. synchronized(thread1)
9. {
10. thread1.interrupt();
11. }
12. }
13. }
14.
15. class MyThread extends Thread
16. {
17. public void run()
18. {
19. for(int i=0;i<10000;i++)
20. {
21. System.out.println("<"+i+">线程运行中......");
22. try
23. {
24. Thread.sleep(1000);
25. }
26. catch(InterruptedException ie)
27. {
28. System.out.println("线程被终止");
29. break;
30. }
31. }
32. }
33. }
运行效果如下：
<0>线程运行中......
<1>线程运行中......
<2>线程运行中......
<3>线程运行中......
<4>线程运行中......
<5>线程运行中......
线程被终止
利用线程的休眠和中断机制，可以不留遗患地完美结束线程，是终止线程的推荐做法。例程虽然很简单，但是对于更复杂的场景，也可以遵照这个模型来设计线程的终止机制。
在和终止线程有关的方法中，Thread类还提供了一系列join()方法来等待线程结束。请注意，join()方法并不能终止某线程，而是提供了一个阻塞当前线程、等待某线程终止的途径。对join()方法说明如下。
— void join()：一直阻塞当前线程，等待线程结束。在等待过程中，如果遇上中断请求，则抛出InterruptedException异常。
— void join(long timeout)：在timeout指定的毫秒时间内阻塞当前线程，等待线程结束。在等待过程中，如果遇上中断请求，则抛出InterruptedException异常。
— void join(long timeout, int nanos)：在timeout指定的毫秒＋nanos指定的微秒时间内阻塞当前线程，等待线程结束。在等待过程中，如果遇上中断请求，则抛出InterruptedException异常。
下面的例程演示join()方法的用法。主线程等待子线程thread1的结束，并打印耗费在等待上的时间长度。源代码如下。
代码清单7‑10 终止线程的例程——JoinThread
1. public class JoinThread
2. {
3. public static void main(String[] args) throws InterruptedException
4. {
5. TestThread thread1=new TestThread();
6. thread1.start();
7. long beginTime=System.currentTimeMillis();
8. thread1.join();
9. long endTime=System.currentTimeMillis();
10. System.out.println("等待"+(endTime-beginTime)/1000+"秒后线程终止");
11. }
12. }
13.
14. class TestThread extends Thread
15. {
16. public void run()
17. {
18. for(int i=0;i<10;i++)
19. {
20. System.out.println("<"+i+">线程运行中......");
21. try
22. {
23. Thread.sleep(1000);
24. }
25. catch(InterruptedException ie)
26. {
27. ie.printStackTrace();
28. }
29. }
30. }
31. }
运行效果如下：
<0>线程运行中......
<1>线程运行中......
<2>线程运行中......
<3>线程运行中......
<4>线程运行中......
<5>线程运行中......
<6>线程运行中......
<7>线程运行中......
<8>线程运行中......
<9>线程运行中......
等待10秒后线程终止
如果预计子线程运行时间较长，不允许主线程无限阻塞一直等待其结束的话，可以沿用下面的代码框架，间歇性地等待一段时间之后，如果仍然没有结束，则转而处理其他任务：
循环标志:
thread.join(一段时间);
if(thread.isAlive()) //如果thread线程仍然没有结束
{
//处理其他任务
continue 循环标志
}
从“图7-1线程的6种状态”中可以看到，调用Thread类的yield()方法可以使某线程主动�