1线程的生命周期
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态，在线程的声明周期中，它要经过新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead） 5种状态。尤其是当线程启动以后，它不可能一直“霸占”着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换。
1.1新建和就绪状态
当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时它和其他的Java对象一样，仅仅由Java虚拟机为其分配内存，并初始化其成员变量的值。此时的线程对象没有表现出任何线程的动态特征，程序也不会执行线程的线程执行体。
当线程对象调用了strat()方法之后，该线程处于就绪状态，Java虚拟机会为其创建方法调用栈和程序计算器，处于这个状态的线程并没有开始运行，只是表示该线程可以运行了。至于该线程何时开始运行，取决于JVM里线程调度器的调度。
启动线程使用start()方法，而不是run()方法！永远不要调用线程对象的run()方法！调用start()方法来启动线程，系统会把该run()方法当成线程执行体来处理；但如果直接调用线程对象的run()方法，则run()方法立即就会被执行，而且在run()方法返回之前其他线程无法并发执行——也就是说，系统把线程对象当成一个普通对象，而run()方法也是一个普通方法，而不是线程执行体。
看如下例子：
package InvokeRun;
public class InvokeRun extends Thread {
private int i;
// 重写run()方法，run()方法的方法体就是线程执行体
public void run() {
for (; i < 100; i++) {
// 直接调用run()方法时，Thread的this.getName()返回的是该对象的名字
// 而不是当前线程的名字
// 使用Thread.currentThread().getName()总是获取当前线程的名字
System.out.println(Thread.currentThread().getName()
+ " " + i); // ①
}
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
// 调用Thread的currentThread()方法获取当前线程
System.out.println(Thread.currentThread().getName()
+ " " + i);
if (i == 20) {
// 直接调用线程对象的run()方法
// 系统会把线程对象当成普通对象，把run()方法当成普通方法，
// 所以下面两行代码并不会启动两个线程，而是依次执行两个run()方法
new InvokeRun().run();
new InvokeRun().run();
}
}
}
}
上面程序创建线程对象后直接调用了线程对象的run()方法（如粗体字代码所示），程序运行的结果是整个程序只有一个线程：主线程。还有一点需要指出，如果直接调用线程对象的run()方法，则run()方法里不能直接通过getName()方法来获得当前执行线程的名字，而是需要使用Thread.currentThread()方法先获得当前线程，再调用线程对象的getName()方法来获得线程的名字。
通过上面程序不难看出，启动线程的正确方式是调用Thread对象的start()方法，而不是直接调用run()方法，否则就变成单线程程序了。调用了线程的run()方法之后，该线程已经不再处于新建状态，不要再次调用线程对象的start()方法。只能对处于新建状态的线程调用start()方法，否则将引发IllegalThreadStateException异常。
调用线程对象的start()方法之后，该线程立即进入就绪状态——就绪状态相当于“等待执行”，但该线程并未真正进入运行状态。
如果希望调用子线程的start()方法后子线程立即开始执行，程序可以使用Thread.sleep (1)来让当前运行的线程（主线程）睡眠1毫秒——1毫秒就够了，因为在这1毫秒内CPU不会空闲，它会去执行另一个处于就绪状态的线程，这样就可以让子线程立即开始执行。
1.2 运行和阻塞状态
如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态，如果计算机只有一个CPU，那么在任何时刻只有一个线程处于运行状态。当然，在一个多处理器的机器上，将会有多个线程并行（注意是并行：parallel）执行；当线程数大于处理器数时，依然会存在多个线程在同一个CPU上轮换的现象。
当一个线程开始运行后，它不可能一直处于运行状态（除非它的线程执行体足够短，瞬间就执行结束了），线程在运行过程中需要被中断，目的是使其他线程获得执行的机会，线程调度的细节取决于底层平台所采用的策略。对于采用抢占式策略的系统而言，系统会给每个可执行的线程一个小时间段来处理任务；当该时间段用完后，系统就会剥夺该线程所占用的资源，让其他线程获得执行的机会。在选择下一个线程时，系统会考虑线程的优先级。
所有现代的桌面和服务器操作系统都采用抢占式调度策略，但一些小型设备如手机则可能采用协作式调度策略，在这样的系统中，只有当一个线程调用了它的sleep()或yield()方法后才会放弃所占用的资源——也就是必须由该线程主动放弃所占用的资源。当发生如下情况时，线程将会进入阻塞状态：
- 线程调用sleep()方法主动放弃所占用的处理器资源。
- 线程调用了一个阻塞式IO方法，在该方法返回之前，该线程被阻塞。
- 线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有。关于同步监视器的知识、后面将有更深入的介绍。
- 线程在等待某个通知（notify）。
- 程序调用了线程的suspend()方法将该线程挂起。但这个方法容易导致死锁，所以应该尽量避免使用该方法。
当前正在执行的线程被阻塞之后，其他线程就可以获得执行的机会。被阻塞的线程会在合适的时候重新进入就绪状态，注意是就绪状态而不是运行状态。也就是说，被阻塞线程的阻塞解除后，必须重新等待线程调度器再次调度它。
针对上面几种情况，当发生如下特定的情况时可以解除上面的阻塞，让该线程重新进入就绪状态：
- 调用sleep()方法的线程经过了指定时间。
- 线程调用的阻塞式IO方法已经返回。
- 线程成功地获得了试图取得的同步监视器。
- 线程正在等待某个通知时，其他线程发出了一个通知。
- 处于挂起状态的线程被调用了resume()恢复方法。
下图为线程状态转换图：
线程从阻塞状态只能进入就绪状态，无法直接进入运行状态。而就绪和运行状态之间的转换通常不受程序控制，而是由系统线程调度所决定，当处于就绪状态的线程获得处理器资源时，该线程进入运行状态；当处于运行状态的线程时区处理器资源时，调用yield()方法可以让运行状态的线程转入就绪状态。关于yield()方法后面有更详细的介绍。
1.3 线程死亡
线程会以如下3种方式结束，结束后就处于死亡状态：
- run()和call()方法执行完成，线程正常结束。
- 线程抛出一个未捕获的Exception或Error。
- 直接调用该线程的stop()方法来结束该线程——该方法容易导致死锁，通常不推荐使用。
为了测试某个线程是否已经死亡，可以调用线程对象的isAlive()方法，当线程处于就绪、运行、阻塞3种状态时，该方法将返回true;当线程处于新建、死亡2种状态时，该方法将返回false。
不要试图对一个已经死亡的线程调用start()方法使它重新启动，死亡就是死亡，该线程将不可再次作为线程执行。
下面程序尝试对处于死亡状态的线程再次调用start()方法：
public class StartDead extends Thread {
private int i;
// 重写run方法
public void run() {
for ( ; i < 100 ; i++ ) {
System.out.println(getName() + " " + i);
}
}
public static void main(String[] args) {
// 创建线程对象
StartDead sd=new StartDead();
for (int i=0; i < 300; i++) {
// 调用Thread的currentThread()方法获取当前线程
System.out.println(Thread.currentThread().getName()
+ " " + i);
if (i==20) {
// 启动线程
sd.start();
// 判断启动后线程的isAlive()值，输出true
System.out.println(sd.isAlive());
}
// 当线程处于新建、死亡两种状态时，isAlive()方法返回false
// 当i > 20时，该线程肯定已经启动过了，如果sd.isAlive()为假时，
// 那就是死亡状态了
if (i > 20 && !sd.isAlive()){
// 试图再次启动该线程
sd.start();
}
}
}
}
上面程序中的粗体字代码试图在线程已死亡的情况下再次调用start()方法来启动该线程。运行上面程序，将引发IllegalThreadStateException异常，这表明处于死亡状态的线程无法再次运行了。
不要对处于死亡状态的线程调用start方法，程序只能对新建状态的线程调用start方法，对新建状态的线程两次调用start()方法也是错误的。这都会引发IllegalThreadState Exception异常。
2 控制线程
Java的线程支持提供了一些便捷的工具方法，通过这些便捷的工具方法可以很好地控制线程的执行。
2.1 join线程
Thread提供了让一个线程等待另一个线程完成的方法——join()方法。当在某个程序执行流中调用其他线程的join()方法的，调用线程将被阻塞，直到被join()方法加入的join线程执行完为止。
join()方法通常由使用线程的程序调用，以将大问题划分成许多小问题，每个小问题分配一个线程。当所有的小问题都得到处理后，再调用主线程来进一步操作：
package JoinThread;
public class JoinThread extends Thread {
public JoinThread(String name) {
super(name);
}
// 重写run()方法，定义线程执行体
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + " " + i);
}
}
public static void main(String[] args) throws Exception {
//启动子线程
new JoinThread("新线程").start();
for (int i = 0; i < 100; i++) {
if (i==20) {
JoinThread jt=new JoinThread("被Join的线程");
jt.start();
// main线程调用了jt线程的join()方法，main线程
// 必须等jt执行结束才会向下执行
jt.join();
}
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
}
上面程序中一共有3个线程，主方法开始时就启动了名为“新线程”的子线程，该子线程将会和main线程并发执行。当主线程的循环变量i等于20时，启动了名为“被Join的线程”的线程，该线程不会和main线程并发执行，main线程必须等该线程执行结束后才可以向下执行。在名为“被Join的线程”的线程执行时，实际上只有2个子线程并发执行，而主线程处于等待状态。
join()方法有如下3种重载形式：
- join()：等待被join的线程执行完成。
- join(long millis)：等待被join的线程的时间最长为millis毫秒。如果在millis毫秒内被join的线程还没有执行结束，则不再等待。
- join(long millis, int nanos)：等待被join的线程的时间最长为millis毫秒加nanos毫微秒。
通常我们很少使用第3种形式的方法，原因有两个：程序对时间的精度无须精确到毫微秒；计算机硬件、操作系统本身也无法精确到毫微秒。
2.2 后台线程
有一个线程，它是在后台运行的，它的任务是为其他的线程提供服务，这种线程被称为“后台线程（Daemon Thread）”，又称为“守护线程”或“精灵线程”。JVM的垃圾回收线程就是典型的后台线程。
后台线程有个特征：如果所有的前台线程都死亡，后台线程会自动死亡。
调用Thread对象的setDaemon(true)方法可将指定线程设置后台线程。下面程序将执行线程设置成后台线程，可以看到当所有的前台线程死亡时，后台线程随之死亡。当整个虚拟机中只剩下后台线程时，程序就没有继续运行的必要了，所以虚拟机也就退出了：
package DaemonThread;
public class DaemonThread extends Thread {
// 定义后台线程的线程执行体与普通线程没有任何区别
public void run() {
for (int i=0; i < 1000 ; i++ ) {
System.out.println(getName() + " " + i);
}
}
public static void main(String[] args) {
DaemonThread t=new DaemonThread();
// 将此线程设置成后台线程
t.setDaemon(true);
// 启动后台线程
t.start();
for (int i=0 ; i < 10 ; i++ ) {
System.out.println(Thread.currentThread().getName()
+ " " + i);
}
// -----程序执行到此处，前台线程（main线程）结束------
// 后台线程也应该随之结束
}
}
上面程序中的粗体字代码先将t线程设置成后台线程，然后启动该线程，本来该线程应该执行到i等于999时才会结束，但运行程序是不难发现该后台线程无法运行到999，因为当主线程就是程序中唯一的前台线程运行结束后，JVM会主动退出，因而后台线程也就被结束了。
Thread类还提供了一个isDaemon()方法，用于判断指定线程是否为后台线程。
从上面程序可以看出，主线程默认是前台线程，t线程默认也是前台线程。并不是所有的线程默认都是前台线程，有些线程默认就是后台线程——前台线程创建的子线程默认是前台线程，后台线程创建的子线程默认是后台线程。
前台线程死亡后，JVM会通知后台线程死亡，但从它接收指令到做出响应，需要一定时间。而且要将某个线程设置为后台线程，必须在该线程启动之前设置，也就是说， setDaemon(true)必须在start()方法之前调用，否则会引发IllegalThreadStateException异常。
2.3 线程睡眠：sleep
如果需要当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread类的静态sleep()方法来实现。sleep()方法有两种重载形式：
- static void sleep(long millis)：让当前正在执行的线程暂停millis毫秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响。
- static void sleep(long millis, int nanos)：让当前正在执行的线程暂停millis毫秒加nanos毫微秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响。
与前面类似的是，程序很少调用第二种形式的sleep()方法。
当当前线程调用sleep()方法进入阻塞状态后，在其书面时间段内，该线程不会获得执行的机会，即使系统中没有其他可执行的线程，处于sleep()中的线程也不会执行，因此sleep()方法常用来暂停程序的执行。
下面程序调用sleep()方法来暂停主线程的执行，因为该程序只有一主线程，当主线程进入睡眠后，系统没有可执行的线程，所以可以看到程序在sleep()方法处暂停。
import java.util.Date;
public class SleepTest {
public static void main(String[] args)
throws Exception {
for (int i = 0; i < 10; i++) {
System.out.println("当前时间: " + new Date());
// 调用sleep()方法让当前线程暂停1s
Thread.sleep(1000);
}
}
}
上面程序中的粗体字代码将当前执行的线程暂停1秒，运行上面程序，看到程序依次输出10条字符串，输出2条字符串之间的时间间隔为1秒。
2.4 线程让步：yield
yield()方法是一个和sleep()方法有点相似的方法，它也是Thread类提供的一个静态方法，它也可以让当前正在执行的线程暂停，但它不会阻塞该线程，它只是将该线程转入就绪状态。yield()只是让当前线程暂停一下，让系统的线程调度器重新调度一次，完全可能的情况是：当某个线程调用了yield()方法暂停之后，线程调度器又将其调度出来重新执行。
实际上，当某个线程调用了yield()方法暂停之后，只有优先级与当前线程相同，或者优先级比当前线程更高的处于就绪状态的线程才会获得执行的机会。下面程序使用yield()方法来让当前正在执行的线程暂停：
public class YieldTest extends Thread {
public YieldTest(String name) {
super(name);
}
// 定义run()方法作为线程执行体
public void run() {
for (int i=0; i < 50 ; i++ ) {
System.out.println(getName() + " " + i);
// 当i等于20时，使用yield()方法让当前线程让步
if (i==20)
{Thread.yield(); }
}
}
public static void main(String[] args)throws Exception {
// 启动两个并发线程
YieldTest yt1=new YieldTest("高级");
// 将yt1线程设置成最高优先级
yt1.setPriority(Thread.MAX_PRIORITY);
yt1.start();
YieldTest yt2=new YieldTest("低级");
// 将yt2线程设置成最低优先级
yt2.setPriority(Thread.MIN_PRIORITY);
yt2.start();
}
}
上面程序中的第一行粗体字代码调用yield()静态方法让当前正在执行的线程暂停，让系统线程调度器重新调度。
关于sleep()方法和yield()方法的区别如下：
- sleep()方法暂停当前线程后，会给其他线程执行机会，不会理会其他线程的优先级；但yield()方法只会给优先级相同，或优先级更高的线程执行机会。
- sleep()方法会将线程转入阻塞状态，直到经过阻塞时间才会转入就绪状态；而yield()不会讲线程转入阻塞状态，它只是强制当前线程进入就绪状态。因此完全有可能某个线程调用yield()方法暂停之后，立即再次获得处理器资源被执行。
- sleep()方法声明抛出了InterruptedException异常，所以调用sleep()方法时要么捕捉该异常，要么显式声明抛出该异常；而yield()方法则没有声明抛出任何异常。
- sleep()方法比yield()方法有更好的可移植性，通常不建议使用yield()方法来控制并发线程的执行。
2.5 更改线程优先级
每个线程执行时都具有一定的优先级，优先级高的线程获得较多的执行机会，而优先级低的线程则获得较少的执行机会。
每个线程默认的优先级都与创建它的父线程的优先级相同，在默认情况下，main线程具有普通优先级，由main线程创建的子线程也具有普通优先级。
Thread类提供了setPriority(int newPriority)、getPriority()方法来设置和返回指定线程的优先级，其中setPriority()方法的参数可以是一个整数，范围是1～10之间，也可以使用Thread类的如下3个静态常量。
- MAX_PRIORITY：其值是10。
- MIN_PRIORITY：其值是1。
- NORM_PRIORITY：其值是5。
下面程序使用了setPriority()方法来改变主线程的优先级，并使用该方法改变了两个线程的优先级，从而可以看到高优先级的线程将会获得更多的执行机会：
public class PriorityTest extends Thread {
// 定义一个有参数的构造器，用于创建线程时指定name
public PriorityTest(String name) {
super(name);
}
public void run() {
for (int i=0 ; i < 50 ; i++ ) {
System.out.println(getName() + ",其优先级是："
+ getPriority() + ",循环变量的值为:" + i);
}
}
public static void main(String[] args) {
// 改变主线程的优先级
Thread.currentThread().setPriority(6);
for (int i=0 ; i < 30 ; i++ ) {
if (i==10) {
PriorityTest low=new PriorityTest("低级");
low.start();
System.out.println("创建之初的优先级:"
+ low.getPriority());
// 设置该线程为最低优先级
low.setPriority(Thread.MIN_PRIORITY);
}
if (i==20) {
PriorityTest high=new PriorityTest("高级");
high.start();
System.out.println("创建之初的优先级:"
+ high.getPriority());
// 设置该线程为最高优先级
high.setPriority(Thread.MAX_PRIORITY);
}
}
}
}
值得指出的是，虽然Java提供了10个优先级级别，但这些优先级级别需要操作系统的支持。遗憾的是，不同操作系统上的优先级并不相同，而且也不能很好地和Java的10个优先级对应，例如Windows 2000仅提供了7个优先级。在这种情况下，我们应该尽量避免直接为线程指定优先级，而应该使用MAX_PRIORITY、MIN_PRIORITY和NORM_PRIORITY三个静态常量来设置优先级，这样才可以保证程序具有最好的可移植性。
3Java编程练习
3.3设置线程优先级分配CPU运行时间
默认情况下，所有的线程都按照正常的优先级来运行及分配CPU资源。JVM允许程序员自行设置线程优先级。理论上，优先级高的线程比优先级低的线程获得更多的CPU时间。本例为设置线程优先级分配CPU运行时间，共设置了两个线程，一个线程设置了高于普通级两级的级数，另一个则低于普通级两级。两个线程被启动并允许运行10秒。每个线程执行一个循环，记录反复的次数。
3.3.1
新建项目Priorities，并在其中创建一个clicker.java文件。在该类的主方法中创建了run()方法来定义了线程的执行：
package Priorities;
public class clicker extends Thread{
private int click = 0;
private volatile boolean running = true;
public int getClick() {
return click;
}
public void run() {
while(running)
click = click + 1;
}
public void mormalStop() {
running = false;
}
}
3.3.2.
编写一个demoPri类进行测试，在main()方法中，设置了两个线程的优先级，并对其进行启动运行。关键代码如下所示：
package Priorities;
public class demoPri {
public static void main(String[] argv) {
clicker trHigh, trLow;
// 创建两个线程对象
trHigh = new clicker();
trLow = new clicker();
// 分别设置优先级
trHigh.setPriority(Thread.NORM_PRIORITY+2);
trLow.setPriority(Thread.NORM_PRIORITY-2);
// 启动这两个线程
trLow.start();
trHigh.start();
try {
Thread.sleep(1000); // 等待1s
} catch (InterruptedException e) { }
trHigh.mormalStop();
trLow.mormalStop();
// 等待他们真正结束
try {
trHigh.join();
trLow.join();
}catch (InterruptedException e){}
// 输出两个线程的循环次数
System.out.println("trHigh的循环次数为：" + trHigh.getClick());
System.out.println("trLow的循环次数为：" + trLow.getClick());
}
}
运行程序，结果如下：
trHigh的循环次数为：568674336
trLow的循环次数为：555724533
3.2 篮球运动员的比赛安排（线程的休眠和唤醒）
Java中线程的休眠是指让正在运行的线程暂停执行一段时间，进入阻塞状态，通过调用Thread类的静态方法sleep()得以实现。当线程调用sleep()进入阻塞状态后，在其休眠的时间内，该线程不会获得执行的机会，即使系统中没有其他可运行的线程，处于休眠中的线程也不会执行，因此常用sleep()方法来暂停程序的执行。我们模拟篮球运动员在一次比赛中的比赛安排来学习线程的休眠和唤醒的方法。
3.2.1.
新建项目SleepAndWake，并在其中创建一个SleepAndWake.java文件。在该类的主方法中分别使用start()方法、sleep()方法和interrupt()方法来启动、休眠和唤醒线程。核心代码如下所示：
package SleepAndWake;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SleepAndWake extends Thread {
private DateFormat df = new SimpleDateFormat("ss：SS");
public static void main(String[] args) { // Java程序主入口处
SleepAndWake relay = new SleepAndWake(); // 实例化对象
relay.start(); // 启动线程
try {
relay.join(); // 等待线程运行结束
} catch (InterruptedException e) { // 捕获唤醒异常
System.out.println(" 收到命令，准备上场：" + e.getMessage());
}
relay.incident(); // 调用方法判断是否唤醒
}
public void incident() {
Thread.currentThread().interrupt(); // 唤醒当前线程
while (true) {
if (Thread.currentThread().isInterrupted()) { // 判断当前线程是否被唤醒
System.out.print(df.format(new Date()) + "现在是否正在准备上场？ ");
System.out.println(Thread.currentThread().isInterrupted() ? "是"
: "没有");
try {
Thread.currentThread().sleep(3000); // 线程休眠3秒
} catch (InterruptedException e) { // 捕获唤醒异常
System.out.println(df.format(new Date()) + " 收到命令，停止休息："
+ e.getMessage());
}
System.out.print(df.format(new Date()) + " 比赛结束后是否参加下一轮比赛？ ");
System.out.println(Thread.currentThread().isInterrupted() ? "是": "不参加");
}
}
}
public void run() {
System.out.println("第一场比赛结束的时间为：" + df.format(new Date()));
System.out.println("休息5小时");
try {
sleep(2000); // 线程休眠2秒 在程序假设1秒=1小时
} catch (InterruptedException e) { // 捕获唤醒异常
System.out.println(df.format(new Date()) + "收到命令，准备上场："
+ e.getMessage());
}
System.out.print(df.format(new Date()) + " 在休息的过程中是否又参加其他的比赛？");
try {
sleep(2000); // 线程休眠2秒
} catch (InterruptedException e) { // 捕获唤醒异常
System.out.println(df.format(new Date()) + "收到命令，准备上场："
+ e.getMessage());
}
System.out.println(!isAlive() ? "参加比赛" : "没有参加其他的比赛"); // 线程是 否激活,false表不是激活的
interrupt(); // 唤醒线程
System.out.print(df.format(new Date()) + " 休息中，替补队员受伤，是否参加比赛？ ");
System.out.println(isAlive() ? "参加比赛" :"不参加比赛"); // 线程是否激活
}
}
sleep()方法是一个静态的方法，所以sleep()方法不是依赖于某一个对象的，位置比较随意，当在线程中执行sleep()方法，则线程就进入睡眠状态。sleep()方法是可能发生捕获异常的，所以在使用sleep()方法时必须进行异常处理。
3.3 爱情对对碰（join方法）
当前电视相亲节目异常火爆，如非诚勿扰、爱情对对碰等都是收视率很高的节目。实际上，我们也可以使用Java多线程程序来实现这种相亲程序，这就用到了线程join()等待方法。比如我们对只运行一次的线程设定为可以配对，而对重复获得执行的线程设定为警告
3.3.1.
新建项目Lover，并在其中创建一个Lover.java文件。在该类的主方法中首先实例化四组对象，然后启动线程，并捕获唤醒异常，对于重复执行的线程设为警告：
package Lover;
class MatchMarry extends Thread {
// 测试匹配结婚的类
private String name; // 人员名称
private String otherName; // 结婚对象
// 是否结婚
private boolean isMarry = false;
public MatchMarry(String name, String otherName) {
// 带参数构造方法进行初始化
this.name = name;
this.otherName = otherName;
}
public void run() {
try {
int person = (int) Math.floor((Math.random() * 10 + 1)); // 获得随机数
// 设置标识
if (person % 2 == 0) {
isMarry = true;
} else {
isMarry = false;
}
if (!isMarry) {
System.out.println(name + "可以与" + otherName + "结婚，祝福你们");
} else {
System.out.println(otherName + "已婚， 警告：对待婚姻不要有二心");
}
Thread.sleep(200);
} catch (InterruptedException e) {
System.out.println("唤醒异常："+e.getMessage());
}
}
}
public class Lover {
public static void main(String[] args) {
MatchMarry group1 = new MatchMarry("ffzs", "sleepycat"); // 实例化对象
MatchMarry group2 = new MatchMarry("皮特", "莫莫");
MatchMarry group3 = new MatchMarry("vincent", "丽丽");
MatchMarry group4 = new MatchMarry("tom", "lilith");
MatchMarry group5 = new MatchMarry("vv", "mary");
System.out.println("非诚勿扰！情比金坚！");
group1.start(); // 启动线程
try {
group1.join(); // 等待线程运行结束
} catch (InterruptedException e) { // 捕获唤醒异常
System.out.println("唤醒异常：" + e.getMessage());
}
group2.start();
try {
group2.join(); // 等待线程运行结束
} catch (InterruptedException e) { // 捕获唤醒异常
System.out.println("唤醒异常：" + e.getMessage());
}
group3.start();
try {
group3.join(); // 等待线程运行结束
} catch (InterruptedException e) { // 捕获唤醒异常
System.out.println("唤醒异常：" + e.getMessage());
}
group4.start();
try {
group4.join(); // 等待线程运行结束
} catch (InterruptedException e) { // 捕获唤醒异常
System.out.println("唤醒异常：" + e.getMessage());
}
group5.start();
try {
group5.join(); // 等待线程运行结束
} catch (InterruptedException e) { // 捕获唤醒异常
System.out.println("唤醒异常：" + e.getMessage());
}
System.out.println("速配结束...");
}
}
对于正在执行的线程，可以调用join()方法等待其结束，然后才执行其他程序。join()方法有几种重载形式。其中，不带任何参数是等到执行结束为止，其他重载形式可参考JDK API。join()方法也会抛出可控异常InterruptedException，程序需要对此异常进行处理。