Java多线程初探——正确停止线程

一、错误的方法——stop()方法

在1.0版本的jdk中，提供了一个stop方法来停止线程，但是这个方法现在已经被废弃了，因为使用这个方法停止线程，将会使线程戛然而止，我们甚至不知道程序执行到了哪里，资源是否已经释放，会出现一些不可预料的结果。

使用stop()方法停止线程实例：

定义一个线程类YieldRunnable.java

public class YieldRunnable implements Runnable{
	public volatile boolean isRunning = true;
	
	@Override
	public void run() {
		String name = Thread.currentThread().getName();
		System.out.println(name + "开始执行！");
		
		while(isRunning) {
			for(int i = 1; i < 6; i++) {
				System.out.println(name + "执行了[" + i + "]次");
				//注意，yield是静态方法
				Thread.yield();
			}
		}
		
		System.out.println(name + "执行结束！");
	}
}

接下来是main方法

	public static void main(String[] args) {
		System.out.println("主线程开始执行！");
		YieldRunnable runnable = new YieldRunnable();
		Thread thread = new Thread(runnable, "线程1");
		
		thread.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		thread.stop();

		System.out.println("主线程执行结束！");
	}

截取部分执行结果片段：

……

线程1执行了[1]次
线程1执行了[2]次
线程1执行了[3]次
线程1执行了[4]次
线程1执行了[5]次
线程1执行了[1]次线程1执行了[1]次主线程执行结束！

从执行结果可以看出，在调用了stop方法之后，线程中的循环语句还没有执行结束线程就戛然而止了，甚至连最后执行结束的输出都没有打印出来，我们甚至不知道程序执行到哪里了，所以stop()方法是不推荐使用的。

二、正确的方法——使用中断信号

所谓使用中断信号，就是定义一个布尔型的标志位，用于标识线程是否继续执行，线程不定期检查该标志位，当需要将线程停止时，将标志位修改为中断，那么线程就可以被正确停止了。

使用中断信号停止线程实例：

YieldRunnable.java与上例相同，不做修改，写一个main方法

	public static void main(String[] args) {
		System.out.println("主线程开始执行！");
		YieldRunnable runnable = new YieldRunnable();
		Thread thread = new Thread(runnable, "线程1");
		
		thread.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		runnable.isRunning = false;

		System.out.println("主线程执行结束！");
	}

上面的程序将YieldRunnable类中的isRunning设为中断信号，刚开始主线程运行，启动了子线程，之后主线程将子线程的中断信号设为false，子线程读取到中断信号之后就结束线程。
运行结果：

……

线程1执行了[4]次
线程1执行了[5]次
线程1执行了[1]次
线程1执行了[2]次
线程1执行了[3]次
线程1执行了[4]次
线程1执行了[5]次
主线程执行结束！
线程1执行结束！

由运行结果可以发现，子线程正确执行了所有的循环，并打印退出信息正确退出了。

三、另一种值得推敲的方法，interrupt()方法

在Java中还提供了一个方法，interrupt()方法，在jdk文档中这样描述：中断线程，这个方法真的能将线程停止吗？现在用一个实例尝试一下。

先写一个线程YieldRunnable.java

public class YieldRunnable implements Runnable{
	@Override
	public void run() {
		String name = Thread.currentThread().getName();
		System.out.println(name + "开始执行！");
		
		while(true) {
			for(int i = 1; i < 6; i++) {
				System.out.println(name + "执行了[" + i + "]次");
				//注意，yield是静态方法
				Thread.yield();
			}
			long time = System.currentTimeMillis();
			while(System.currentTimeMillis() - time < 1000) {
	            /*
	             * 使用while循环模拟 sleep 方法，这里不要使用sleep，具体原因下面再说
	             */
			}
		}		
	}
}

再写一个main方法

	public static void main(String[] args) {
		System.out.println("主线程开始执行！");
		YieldRunnable runnable = new YieldRunnable();
		Thread thread = new Thread(runnable, "线程1");
		
		thread.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		thread.interrupt();

		System.out.println("主线程执行结束！");
	}

运行之后会发现，虽然执行了interrupt()方法，但是子线程并没有停下来，反而是一直执行下去，由此可以得知，interrupt()方法单独使用不能停止线程。那该如何使用interrupt()方法让它能够来停止线程呢？查阅了jdk之后，我们发现线程保有一个状态叫做中断状态，在调用interrupt()之后，线程的中断状态为true，Java提供两种方法获取线程的中断状态：

public static boolean interrupted();
public boolean isInterrupted()

其中，interrupted()方法是静态的，同时调用了interrupted()方法之后线程的中断状态由该方法清除，换句话说，如果连续两次调用该方法，则第二次调用将返回 false。isInterrupted()方法则不会清除线程的中断状态。

现在修改上面的示例代码：

YieldRunnable.java

public class YieldRunnable implements Runnable{
	@Override
	public void run() {
		String name = Thread.currentThread().getName();
		System.out.println(name + "开始执行！");
		
		while(!Thread.currentThread().isInterrupted()) {
			for(int i = 1; i < 6; i++) {
				System.out.println(name + "执行了[" + i + "]次");
				//注意，yield是静态方法
				Thread.yield();
			}
			long time = System.currentTimeMillis();
			while(System.currentTimeMillis() - time < 1000) {
				/*
				* 使用while循环模拟 sleep 方法，这里不要使用sleep，具体原因下面再说
				*/
			}
		}
		System.out.println(name + "执行结束！");
	}
}

执行结果：

主线程开始执行！
线程1开始执行！
线程1执行了[1]次
线程1执行了[2]次
线程1执行了[3]次
线程1执行了[4]次
线程1执行了[5]次
主线程执行结束！
线程1执行结束！

从执行结果可以发现线程正确停止了，其实从代码中可以发现，要想使线程停止，其实还是判断的线程的中断状态，检查的是线程isInterrupted()方法的值，这其实也是一种中断信号。

在上面的线程代码中有一段循环，while(System.currentTimeMillis() - time < 1000)，这个方法是模拟Thread的sleep(long l)方法的，那为什么这里不使用sleep()方法呢？我们从jdk文档里可以看到：当线程调用了interrupt()方法后，如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。也就是说线程不仅不会被中断，系统还会抛出一个异常。尝试修改一下线程的代码：

public class YieldRunnable implements Runnable{
	@Override
	public void run() {
		String name = Thread.currentThread().getName();
		System.out.println(name + "开始执行！");
		
		while(!Thread.currentThread().isInterrupted()) {
			for(int i = 1; i < 6; i++) {
				System.out.println(name + "执行了[" + i + "]次");
				//注意，yield是静态方法
				Thread.yield();
			}
			
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}
		System.out.println(name + "执行结束！");
	}
}

执行结果：

主线程开始执行！
线程1开始执行！
线程1执行了[1]次
线程1执行了[2]次
线程1执行了[3]次
线程1执行了[4]次
线程1执行了[5]次
线程1执行了[1]次java.lang.InterruptedException: sleep interrupted


主线程执行结束！
线程1执行了[2]次
线程1执行了[3]次
……

不仅线程没有结束，在执行sleep()方法的时候还抛出了一个异常。那么对于这种情形下该如何处理才能使线程正确停止呢？一种可行的方法是在sleep()方法抛出异常时，在处理异常的时候再调用interrupt()方法将线程中止。代码如下：

public class YieldRunnable implements Runnable{
	@Override
	public void run() {
		String name = Thread.currentThread().getName();
		System.out.println(name + "开始执行！");
		
		while(!Thread.currentThread().isInterrupted()) {
			for(int i = 1; i < 6; i++) {
				System.out.println(name + "执行了[" + i + "]次");
				//注意，yield是静态方法
				Thread.yield();
			}
			
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				Thread.currentThread().interrupt();
			}

		}
		System.out.println(name + "执行结束！");
	}
}

运行结果：

主线程开始执行！
线程1开始执行！
线程1执行了[1]次
线程1执行了[2]次
线程1执行了[3]次
线程1执行了[4]次
线程1执行了[5]次
主线程执行结束！
线程1执行结束！

从运行结果可以看到，线程就被正确停止了。