suspend(挂起)和resume(继续执行)线程

简介：

        线程挂起 (suspend)和继续执行(resume)，这两个 操作是一对相反的操作 ，被挂起的线程，必须要等到resume()操作后，才能继续执行，咋看之下，这对操作就像 Thread.stop()方法一样好用，但如果你仔细阅读文档说明，会发现它们也早已被标注未废弃方法，并不推荐使用。

        不推荐使用suspend(）去挂起线程的原因，是因为suspend(）在导致线程暂停的同时，并不会去释放任何锁资源。此时，其他任何线程想要访问被它暂用的锁时，都会被牵连，导致无法正常继续运行(如图所示)。直到对应的线程上进行了resume()操作，被挂起的线程才能继续，从而其他阻塞在相关锁上的线程也可以继续执行。但是，如果resume()操作意外地在suspend()前就执行了，那么被挂起的线程可能很难有机会被继续执行。并且，更严重的是：它所占用的锁不会被释放，因此可能会导致整个系统工作不正常。而且，对于被挂起的线程，从它的线程状态上看，居然还是Runnable,这也会严重影响我们对系统当前的判断。

 

案例一：(通过打断点调试)

package com.threadstop.demo;
 
 
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
 
 
/**
 *说明:
 *调用了suspend方法，将t0线程挂起，但是出现的问题是，t0.suspend方法之后的代码不执行了，搞了半天终于知道为什么了，
 *因为在t0里面使用了System.out.println方法了，查看println方法的源代码发现他是个同步的方法，加锁了，这个锁是哪个呢？
 *对就是PrintStream,在Main中的printCurrentAliveThread方法中用到了System.out.println方法，打断点才知道
 *搞了半天阻塞在这里了，因为我们知道suspend方法是不释放锁的，所以导致会阻塞在println方法中，但是有一个前提是t0线程和main线程
 *的println方法中拿到的是同一个锁，这时候在看一下System.out变量时一个static PrintStream，这时候就明了了，因为是static
 *所以对象是相同的，这两个线程拿到的System.out是同一个对象，所以这两个线程也是拿到的是相同的锁的。
 *
 */
 
 
public class ThreadStopLock {
	
	public static void main(String[] args) {
		try {
			//定义线程
			Thread t0 = new Thread() {
				public void run() {
					try {
						for(long i=0;i<1000*1000*10;i++){
							System.out.println(i);
						}
						System.out.println("thread death");
					} catch (Throwable ex) {
						System.out.println("Caught in run: " + ex);
						ex.printStackTrace();
					}
				}
			};
			//开启线程
			t0.start();
			//等待2s之后挂起线程t0
			Thread.sleep(2*1000);
			//挂起线程
			t0.suspend();
			//打印当前的所有线程
			printCurrentAliveThread();
			//等待2s之后恢复线程
			Thread.sleep(2*1000);
			//复活线程
			t0.resume();
			
		} catch (Throwable t) {
			System.out.println("Caught in main: " + t);
			t.printStackTrace();
		}
 
 
	}
	
	/**
	 * 打印当前线程
	 */
	public static void printCurrentAliveThread(){
		Map<Thread, StackTraceElement[]> maps = Thread.getAllStackTraces();
		Set<Entry<Thread, StackTraceElement[]>> set = maps.entrySet();
		Iterator<Entry<Thread,StackTraceElement[]>> iterator = set.iterator();
		System.out.println("System Alive Thread List:");
		System.out.println("-------------------------");
		while(iterator.hasNext()){
			System.out.println("AliveThread_Name:"+iterator.next().getKey().getName());
		}
		System.out.println("-------------------------");
	}
	
}

运行结果(程序被挂起，且不会终止)：

案例二：

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class BadSuspend {
    public static Object u = new Object();
    static ChangeObjectThread t1 = new ChangeObjectThread("t1");
    static ChangeObjectThread t2 = new ChangeObjectThread("t2");

    public static class ChangeObjectThread extends Thread{
        public ChangeObjectThread(String name){
            super.setName(name);
        }
        @Override
        public void run() {
            synchronized (u){
                try{
                    System.out.println("in:" + getName());
                    Thread.currentThread().suspend();
                    System.out.println("thread continue run:" + getName());
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException{
        t1.start();
        t2.start();
        Thread.sleep(2000);
        t1.resume();
        t2.resume();
        t1.join();
        t2.join();
    }

}

运行结果(程序被挂起，且不会终止)：