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

一 停止线程

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

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

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

/** *  * *<p>Description:测试Interrupt方法停止线程</p> * * @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结合实现线程的停止

/** *  * *<p>Description:测试Interrupt方法和retun停止线程</p> * * @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 使用抛异常的方法停止线程

/** *  * *<p>Description:使用异常停止线程</p> * * @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()方法停止线程时，会对锁定的对象进行“解锁”，导致数据得不到同步处理，出现数据不一致的问题。

/** *  * *<p>Description:测试Stop()方法停止线程</p> * * @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 线程的暂停与恢复

/** *  * *<p>Description:测试线程的暂停与恢复</p> * * @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()方法时，如果使用不当，极易造成公共的同步对象的独占，使其他线程无法访问公共同步对象

/** *  * *<p>Description:测试线程的独占</p> * * @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停止线程导致数据不同步的情况类似。

/** *  * *<p>Description:测试线程暂停而导致的数据不同步</p> * * @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();    }}

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