java多线程 —— 为什么弃用stop和suspend

转载请注明出处：http://blog.csdn.net/xingjiarong/article/details/47984659

初始的java版本中定义了一个stop方法来终止一个线程还定义了一个suspend方法来阻塞一个线程，直到另一个线程调用resume方法。这两个方法在Java SE 1.2之后就被弃用了，因为这两种方法都不安全，下面我们分别来讨论一下为什么不安全和应该怎样做才是安全的。

一、stop方法为什么不安全

其实stop方法天生就不安全，因为它在终止一个线程时会强制中断线程的执行，不管run方法是否执行完了，并且还会释放这个线程所持有的所有的锁对象。这一现象会被其它因为请求锁而阻塞的线程看到，使他们继续向下执行。这就会造成数据的不一致，我们还是拿银行转账作为例子，我们还是从A账户向B账户转账500元，我们之前讨论过，这一过程分为三步，第一步是从A账户中减去500元，假如到这时线程就被stop了，那么这个线程就会释放它所取得锁，然后其他的线程继续执行，这样A账户就莫名其妙的少了500元而B账户也没有收到钱。这就是stop方法的不安全性。

二、suspend方法为什么被弃用

suspend被弃用的原因是因为它会造成死锁。suspend方法和stop方法不一样，它不会破换对象和强制释放锁，相反它会一直保持对锁的占有，一直到其他的线程调用resume方法，它才能继续向下执行。

假如有A，B两个线程，A线程在获得某个锁之后被suspend阻塞，这时A不能继续执行，线程B在或者相同的锁之后才能调用resume方法将A唤醒，但是此时的锁被A占有，B不能继续执行，也就不能及时的唤醒A，此时A，B两个线程都不能继续向下执行而形成了死锁。这就是suspend被弃用的原因。

三、如何正确的终止一个线程

class MyThread extends Thread {  
    public volatile boolean flag = true;  
  
    public void run() {  
        while (flag) {  
            System.out.println("线程正在执行");  
            try {  
                Thread.sleep(500);  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
        System.out.println("线程已终止");  
    }  
}  
  
public class Main {  
  
    public static void main(String[] args) {  
        MyThread myThread = new MyThread();  
        myThread.start();  
        try {  
            Thread.sleep(3000);  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
        myThread.flag = false;  
        System.out.println("主线程结束！");  
    }  
}  

class MyThread extends Thread {
	public volatile boolean flag = true;

	public void run() {
		while (flag) {
			System.out.println("线程正在执行");
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("线程已终止");
	}
}

public class Main {

	public static void main(String[] args) {
		MyThread myThread = new MyThread();
		myThread.start();
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		myThread.flag = false;
		System.out.println("主线程结束！");
	}
}

我们可以采用设置一个条件变量的方式，run方法中的while循环会不断的检测flag的值，在想要结束线程的地方将flag的值设置为false就可以啦！注意这里要将flag设置成volitale的，因为volitale可以保证数据的有效性，如果不设置话，可能会造成子线程多执行一次的错误，例如子线程将flag读到自己线程栈中，flag的值为true，此时子线程的交出执行权，操作系统将执行权交给了主线程，主线程执行flag=false；的操作，希望子线程不要再执行了，但是这一改变子线程是不能看到的，所以子线程还会再向下执行一次，然后重新读取flag的值的时候才会终止。

当然你也可以将对flag所有操作都封装在synchronized关键字修饰的方法中，实现互斥访问，也可以达到相同的效果。

四、如何正确的阻塞线程

如果想安全的阻塞线程，引入一个变量suspendRequested并在run方法安全的地方测试它，安全的地方是指该线程没有封锁其他线程需要的对象的地方。当线程发现如果变量已被设置，将会保持等待状态直到它再次被获得为止。

public volatile boolean suspendRequested = false;  
    private Lock suspendLock = new ReentrantLock();  
    private Condition suspendCondition = suspendLock.newCondition();  
  
    public void run() {  
  
        while (true) {  
            if (suspendRequested) {  
                suspendLock.lock();  
                try {  
                    while (suspendRequested)  
                        suspendCondition.await();  
                } catch (Exception e) {  
  
                } finally {  
                    suspendLock.unlock();  
                }  
            }  
        }  
    }  
  
    public void requestSuspend() {  
        suspendRequested = true;  
    }  
  
    public void requestResume() {  
        suspendRequested = false;  
        suspendLock.lock();  
        try {  
            suspendCondition.signalAll();  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            suspendLock.unlock();  
        }  
    }  

public volatile boolean suspendRequested = false;
	private Lock suspendLock = new ReentrantLock();
	private Condition suspendCondition = suspendLock.newCondition();

	public void run() {

		while (true) {
			if (suspendRequested) {
				suspendLock.lock();
				try {
					while (suspendRequested)
						suspendCondition.await();
				} catch (Exception e) {

				} finally {
					suspendLock.unlock();
				}
			}
		}
	}

	public void requestSuspend() {
		suspendRequested = true;
	}

	public void requestResume() {
		suspendRequested = false;
		suspendLock.lock();
		try {
			suspendCondition.signalAll();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			suspendLock.unlock();
		}
	}