Java多线程编程-停止线程 暂停线程

一 停止线程

停止线程是在多线程开发中很重要的技术点，个人总结停止线程有下面三种方法：

1.使用interrupt()方法停止线程

1.1 单独用interrupt()是不能停止线程的，此方法仅仅是在当前线程中打了一个停止线程的标记，并不是真正的停止线程，当运行下面的测试代码时，会发现，线程并未停止。

/**
 * 
 *
 *
Description:测试Interrupt方法停止线程
 *
 * @author：SongJia
 *
 * @date: 2017-4-5上午11:14:38
 *
 */
public class TestThread extends Thread{
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 50000; i++) {
            System.out.println("i:"+i);
        }
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        TestThread thread = new TestThread();
        thread.start();
        Thread.sleep(2000);
        thread.interrupt();
        System.out.println("THE thread whether stop:"+thread.isInterrupted());
    }

}

判断线程是否停止的两个方法：
this.interrupted():测试当前线程是否已中断
测试当前线程是否已经中断，线程的中断状态由该方法清除，也就是如果连续两次调用该方法，则第二次调用将返回false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

this.isInterrupted():测试线程Thread对下岗是否已是中断状态
不清除状态标志

1.2 使用interrupt()与return结合实现线程的停止

/**
 * 
 *
 *
Description:测试Interrupt方法和retun停止线程
 *
 * @author：SongJia
 *
 * @date: 2017-4-5上午11:36:57
 *
 */
public class TestThread extends Thread{

    @Override
    public void run() {
        while (true) {
            if(TestThread.interrupted()){
                System.out.println("The thread is stop!");
                return;
            }
            System.out.println("time="+System.currentTimeMillis());
        }
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        TestThread thread = new TestThread();
        thread.start();
        Thread.sleep(2000);
        thread.interrupt();
    }
}

由上图看出，使用interrupt()与return结合实现线程的停止

---

2 使用抛异常的方法停止线程

/**
 * 
 *
 *
Description:使用异常停止线程
 *
 * @author：SongJia
 *
 * @date: 2017-4-5下午2:28:21
 *
 */
public class TestThread extends Thread{
    @Override
    public void run() {
        super.run();
        try {
            for (int i = 0; i < 500000; i++) {
                if(this.interrupted()){
                    System.out.println("The Thread had alreday stop,exit!");
                    throw new Exception();
                }
                System.out.println("i="+(i+1));
            }
            for (int j = 0; j < 50; j++) {
                System.out.println("J="+(j+1));
            }
        } catch (Exception e) {
            System.out.println("TestThread Catch ");
            e.printStackTrace();
        }
    }

}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        try {
            TestThread myThread = new TestThread();
            myThread.start();
            Thread.sleep(2000);
            myThread.interrupt();
        } catch (Exception e) {
            System.out.println("Main Catch");
            e.printStackTrace();
        }
        System.out.println("End");
    }
}

由程序运行结果图可以看出，在TestThread 类中，第二个for循环的代码没有执行，证明用抛异常的方法停止线程成功。

---

3 使用stop()方法停止线程

3.1 Thread.stop()已经被废除，为什么不建议使用呢，一个重要原因就是调用Thread.stop()方法停止线程时，会对锁定的对象进行“解锁”，导致数据得不到同步处理，出现数据不一致的问题。

/**
 * 
 *
 *
Description:测试Stop()方法停止线程
 *
 * @author：SongJia
 *
 * @date: 2017-4-5上午11:52:22
 *
 */
public class SynchronizedObject {
    private String username="xiaoming";
    private String password="123456";
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    synchronized public void printString(String name,String pass){
        try {
            this.username=name;
            Thread.sleep(100000);
            this.password=pass;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

public class MyThread extends Thread{

    public SynchronizedObject object;
    public MyThread(SynchronizedObject object){
        super();
        this.object=object;
    }

    @Override
    public void run() {
        object.printString("xiaohong", "654321");
    }

}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        SynchronizedObject object = new SynchronizedObject();
        MyThread myThread = new MyThread(object);
        myThread.start();
        Thread.sleep(100);
        myThread.stop();
        System.out.println(object.getUsername()+"=:"+object.getPassword());

    }

}

由上图看出，使用stop()停止线程，出现了数据问题，所以，这个方法不建议大家使用。
顺便说一下，调用stop()方法时会抛出java.lang.ThreadDeath异常，但是在通常情况下，此异常不需要显式地捕捉。

二 暂停线程

在java多线程编程中，暂停线程意味着此线程还可以恢复运行，可以用suspend()方法暂停线程，使用resume()方法恢复线程的执行，但是，使用suspend()与resume()方法时，如果使用不当，也会出现很多问题。
2.1 线程的暂停与恢复

/**
 * 
 *
 *
Description:测试线程的暂停与恢复
 *
 * @author：SongJia
 *
 * @date: 2017-4-5下午3:03:17
 *
 */
public class TestThread extends Thread{
    private  int  i= 0;

    public int getI() {
        return i;
    }
    public void setI(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        while (true) {
            i++;
        }
    }

}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        TestThread thread = new TestThread();
        thread.start();
        Thread.sleep(2000);
        thread.suspend();
        System.out.println("The Thread had alreday suspend:"+thread.getI());
        Thread.sleep(2000);
        System.out.println("The Thread had alreday suspend:"+thread.getI());
        thread.resume();
        System.out.println("The Thread resume:"+thread.getI());
        Thread.sleep(2000);
        thread.suspend();
        System.out.println("The Thread had alreday suspend:"+thread.getI());
        Thread.sleep(2000);
        System.out.println("The Thread had alreday suspend:"+thread.getI());
    }
}

2.2 suspend()与resume()方法的缺点-线程独占
使用suspend()与resume()方法时，如果使用不当，极易造成公共的同步对象的独占，使其他线程无法访问公共同步对象

/**
 * 
 *
 *
Description:测试线程的独占
 *
 * @author：SongJia
 *
 * @date: 2017-4-5下午3:39:46
 *
 */
public class PrintStr {
    synchronized public void printString(){
        System.out.println("Begin");
        if(Thread.currentThread().getName().equals("a")){
            System.out.println("a thread suspend");
            Thread.currentThread().suspend();
        }
        System.out.println("End");
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final PrintStr printStr = new PrintStr();
        Thread thread = new Thread(){
            @Override
            public void run() {
                printStr.printString();
            }
        };
        thread.setName("a");
        thread.start();
        thread.sleep(1000);
        Thread threadTwo = new Thread(){
            @Override
            public void run() {
                System.out.println("ThreadTwo is running ");
                System.out.println("The method printString（） had already locked with \"a\" thread，forever suspend");
                printStr.printString();
                System.out.println("threadTwo is end");
            }
        };
        threadTwo.start();
    }
}

由上面示例程序的运行结果可以看出，“a”线程在执行printString()方法时执行了suspend()方法，独占了printString()方法，导致threadTwo 线程无法访问printString()方法。

2.3 在使用suspend()与resume()方法时也容易出现因为线程暂停而导致数据不同步的情况，这个情况和stop停止线程导致数据不同步的情况类似。

/**
 * 
 *
 *
Description:测试线程暂停而导致的数据不同步
 *
 * @author：SongJia
 *
 * @date: 2017-4-5下午3:41:13
 *
 */
public class User {
    private String name="xiaoming";
    private String password="123456";
    public void setValue(String name,String password){
        this.name=name;
        if(Thread.currentThread().getName().equals("a")){
            System.out.println("\"a\" thread stop");
            Thread.currentThread().suspend();
        }
        this.password=password;
    }
    public void printUsernameAndPassword(){
        System.out.println(name+":"+password);
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final User user = new User();
        Thread thread = new Thread(){
            @Override
            public void run() {
                user.setValue("xiaohong", "654321");
            }
        };
        thread.setName("a");
        thread.start();
        thread.sleep(1000);
        Thread threadTwo = new Thread(){
            @Override
            public void run() {
                user.printUsernameAndPassword();
            }
        };
        threadTwo.start();
    }
}

由上面示例程序的运行结果可以看出，暂停线程之后，出现了数据不同步问题。