Java - 安全的退出线程

stop() 存在的问题

使用 stop() 来退出线程是不安全的。它会解除由线程获取的所有锁，可能导致数据不一致。

举个例子：

public class StopTest {
    public static void main(String[] args) throws Exception {
        Person person = new Person();
        person.setNameAndAge("Tom", 10);
        MyThread thread = new MyThread(person);
        thread.start();
        Thread.sleep(500);
        thread.stop();
        System.out.println(person.toString());
    }
}

class MyThread extends Thread {
    Person person;

    public MyThread(Person person) {
        this.person = person;
    }

    @Override
    public void run() {
        person.setNameAndAge("Lin", 20);
    }
}

class Person{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    synchronized public void setNameAndAge(String name,int age){
        this.name = name;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.age = age;
    }

    @Override
    public String toString() {
        return getName() + "," + getAge();
    }
}

打印输出：

Lin,10

按理说，setNameAndAge() 是一个同步方法，对象 person 总能保证对 name 和 age 同时赋值。因此上例中我们期待的输出应该是 “Lin,20”，由于调用的是 stop()，它会马上释放锁（即使正在同步块中），使得数据不一致。

所以要停止或退出线程，请忘记 stop()。

interrupt() 能退出线程吗?

public class InterruptTest {
    public static void main(String[] args) throws Exception {
        MyThread thread = new MyThread();
        thread.start();
        Thread.sleep(100);
        thread.interrupt();
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        BufferedWriter writer = null;
        try {
            writer = new BufferedWriter(new FileWriter("C:/log.txt"));
            for (int i = 0; i < 5000000; i++) {
                String str = "";
                if (i == 1) {
                    str = i + "";
                } else {
                    str = "\n" + i;
                }
                writer.write(str);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

可以看到输出的文件总行数为 500000，说明 interrupt() 并没有马上终止循环。

interrupt() 仅仅是在当前线程打了一个停止标记，并没有真的停止线程。

异常法退出线程

上代码：

public class Test {
    public static void main(String[] args) {
            MyThread thread = new MyThread();
            thread.start();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            thread.interrupt();
    }
}

class MyThread extends Thread {
    @Override
    public void run(){
        boolean flag = true;
        while (flag) {
            if (this.isInterrupted()) {
                System.out.println("线程即将停止");
                try {
                    throw new InterruptedException();
                } catch (InterruptedException e) {
                    flag = false;
                }

            }
        }
        System.out.println("已经跳出循环，线程停止");
    }
}

打印输出：

线程即将停止
已经跳出循环，线程停止

run 方法执行完，线程自然就结束了。

使用 return 退出线程

public class Test2 {
    public static void main(String[] args) {
        MyThread2 thread = new MyThread2();
        thread.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();
    }
}

class MyThread2 extends Thread {
    @Override
    public void run() {
        while (true) {
            if (this.isInterrupted()) {
                System.out.println("线程停止");
                return;
            }
        }
    }
}

打印输出：

线程停止