1.3线程停止

三种方法
1）stop()，这个方法不安全，所以这方法已过期作废了，不建议使用
2）使用退出标志，使线程正常退出，也就是当run方法完成后线程终止
3）使用interrupt()方法中断线程，但这个方法不会终止一个正在运行的线程，还需要加入一个判断才可以完成线程停止

interrupt()仅是停止标志

interrupt()只是一个停止标志，并不真正停止线程

package com.myThread;

public class Thread1 extends Thread {
    public Thread1() {


    }

    @Override
    public void run() {
        super.run();
        for(int i = 0;i<5000000;i++){
            System.out.println(i);
        }
    }
}

package com.test;

import com.myThread.Thread1;

public class Test1 {
public static void main(String[] args) throws InterruptedException {
    //测试1
    Thread1 thread1 = new Thread1();
    thread1.start();
    Thread.sleep(5000);
    thread1.interrupt();

}
}

完全没有停止

判断是否是停止状态

Java提供了两种方法

• interrupted():当前线程（currentThread）是否中断；
• isInterrupted()：执行线程是否中断；

package com.myThread;

public class Thread1 extends Thread {
    public Thread1() {


    }

    @Override
    public void run() {
        super.run();
        for(int i = 0;i<5000000;i++){
            //System.out.println("i="+(i+1));
        }
    }
}

package com.test;

import com.myThread.Thread1;

public class Test1 {
public static void main(String[] args) throws InterruptedException {
    //测试1
    Thread1 thread1 = new Thread1();
    thread1.start();
    thread1.interrupt();
    System.out.println(thread1.interrupted());
    System.out.println(thread1.interrupted());
    //测试2
    Thread.currentThread().interrupt();
    System.out.println(Thread.interrupted());
    System.out.println(Thread.interrupted());
            // 测试3
        Thread1 thread1 = new Thread1();
        thread1.start();
        thread1.interrupt();
        System.out.println(thread1.isInterrupted());
        System.out.println(thread1.isInterrupted());

}
}

测试1打印结果

false
false

测试2打印结果

true
false

测试3打印结果

true
true

测试1分析：

因为interrupt()源码

    public static boolean interrupted() {
    return currentThread().isInterrupted(true);
    }

这是一个静态方法，而thread1.interrupted()中的thread1继承的是Thread类，所以返回的是判断当前线程是否停止的结果，而当前线程是main，而main一直都在运行，所以返回都是false

测试2分析：
调用了Thread.currentThread().interrupt();所以当前线程即main已经设置了中断状态，为什么第二个返回的是false，因为第一次执行之后会清除中断标志，所以第二次返回false

测试3分析
isInterrupted()不是一个静态方法，并且执行完之后不会清除中断状态标志

总结：
interrupted()判断当前线程是否是中断状态，并在执行后清除该状态标志
isInterrupted()仅仅判断线程对象时候是中断状态

休眠中停止

其实sleep()需要捕捉InterruptedException就知道休眠中不能停止，还是来测试一下

package com.myThread;

public class Thread3 extends Thread {
    public Thread3() {

    }

    @Override
    public void run() {
     try {
        System.out.println("Thread3 run begin");
         Thread.sleep(50000);
         System.out.println("Thread3 run end");
    } catch (InterruptedException e) {
         System.out.println("Thread3 catch e");
        e.printStackTrace();
    }

    }
}

package com.test;

import com.myThread.Thread3;

public class Test3 {
    public static void main(String[] args) {

        // 测试1
        try {
            Thread3 thread3 = new Thread3();
            thread3.start();
            Thread.sleep(2000);
            thread3.interrupt();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


    }
}

测试1打印结果

Thread3 run begin
Thread3 catch e
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at com.myThread.Thread3.run(Thread3.java:12)


异常中断法

package com.test;

import com.myThread.Thread2;

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        // 测试1
        Thread2 thread2 = new Thread2();
        thread2.start();
        Thread.sleep(500);
        thread2.interrupt();
        System.out.println("main 结束");

        // 测试2
        Thread2 thread2 = new Thread2();
        thread2.start();
        Thread.sleep(50);
        thread2.interrupt();
        System.out.println("main 结束");

    }
}

测试1打印结果

499996
499997
499998
499999
这里是for下面
main 结束

测试2打印结果

2775
2776
2777
2778
我要停止了
这里是异常捕捉，中断线程
main 结束
java.lang.Exception
at com.myThread.Thread2.run(Thread2.java:16)


注意：Thread.sleep(5000);这里的数值根据自己计算机的处理速度来调

return中断法

package com.myThread;

public class Thread4 extends Thread {
    public Thread4() {

    }

    @Override
    public void run() {
        super.run();

        for (int i = 0; i < 500000; i++) {
            System.out.println(i);
            if (this.isInterrupted()) {
                System.out.println("我要停止了");
                return;

            }
        }
        System.out.println("这里是for下面");

    }
}

package com.test;

import com.myThread.Thread4;

public class Test4 {
    public static void main(String[] args) throws InterruptedException {
        // 测试1
//      Thread4 thread4 = new Thread4();
//      thread4.start();
//      Thread.sleep(5000);
//      thread4.interrupt();
//      System.out.println("main 结束");

        // 测试2
        Thread4 thread4 = new Thread4();
        thread4.start();
        Thread.sleep(50);
        thread4.interrupt();
        System.out.println("main 结束");

    }
}

测试1打印结果

499997
499998
499999
这里是for下面
main 结束

测试2打印结果

3460
3461
3462
3463
我要停止了
main 结束


异常和return的比较

都能停止线程，但是建议使用异常中断，以为catch能捕获异常并且将异常向上抛，使线程停止事件得到传播

使用stop()造成数据不一致

stop()方法已经作废，使用stop()可能会使一些后续工作得不到完成，另外也可能使对锁定对象进行“解锁”，导致数据得不到同步的处理。
stop()方法会抛出java.lang.ThreadDeath的异常，但是不需要捕捉

package com.myObject;

public class Object5 {
    private String name = "a";
    private String password = "aa";

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    synchronized public void evalute(String name, String password) {
        try {
            this.name = name;
            Thread.sleep(50000);
            this.password = password;
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return "Object5 [name=" + name + ", password=" + password + "]";
    }


}

package com.myThread;

import com.myObject.Object5;

public class Thread5 extends Thread {
    private Object5 object5;

    public Thread5(Object5 object5) {
        this.object5 = object5;
    }

    @Override
    public void run() {
        super.run();
        object5.evalute("b", "bb");

    }
}

package com.test;

import com.myObject.Object5;
import com.myThread.Thread5;

public class Test5 {
    public static void main(String[] args) throws InterruptedException {
        // 测试1
        Object5 object5 = new Object5();
        Thread5 thread5 = new Thread5(object5);
        thread5.start();
        Thread.sleep(500);
        thread5.stop();
        System.out.println(object5.toString());

    }
}

测试1打印结果
Object5 [name=b, password=aa]