一、使用stop()方法（已弃用）

  （1）stop()方法相当于关掉计算机的电源，这是极度危险的，因为我们难以定位线程是执行到什么位置被关闭的，为以后的维护带来麻烦。
  （2）stop()方法会破坏原子逻辑。多线程为了解决共享资源抢占的问题，使用了锁的概念，避免资源不同步。执行stop()方法后被关闭的线程会丢弃所有的锁，导致原子逻辑受损，原来被锁保护的共享资源将处于不连贯的状态，可能导致不安全的操作。

public class Task implements Runnable {
    private int a = 0;
    public void run() {
        synchronized(" ") {
            a++;
            try {
                Thread.sleep(100);
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
            a--;
            String str = Thread.currentThread().getName();
            System.out.println(str + ":a = " + a);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Task task = new Task();
        Thread thread = new Thread(task);

        thread.start();
        for (int i = 0; i < 5; i++) {
            new Thread(task).start();
        }
        thread.stop;
    }
}

  运行结果：

Thread-5 : a = 1
Thread-4 : a = 1
Thread-3 : a = 1
Thread-2 : a = 1
Thread-1 : a = 1

  Task实现Runnable借口，synchronized代码块内部是原子逻辑，a的值会先增加后减小，无论开多少个线程，打印出的结果应该都是a=0。但如果有一个正在执行的线程被stop()，就可能破坏这种原子逻辑。
  第一个线程thread在synchronized代码块未执行完毕就被stop掉，将a的值改为1，由于a是共享变量，因此其他五个线程都打印a=1。stop()方法破坏了原子逻辑，造成了数据不同步。

二、使用volatile标志位

  一般run()方法执行完，线程就会正常结束。然而，常常有些线程是伺服线程，它们需要长时间的运行，在外部某些条件满足的情况下，才能关闭这些线程。一般使用一个变量控制while循环。例如，最直接的方法就是设置一个boolean类型的标志位，并通过设置这个标志为true或false来控制while循环是否退出：

public class ThreadSafe implements Runnable {
    public volatile boolean exit = false;
    public void run() {
        while(!exit) {
            // do something
        }
    }
}

使用volatile关键字的作用：
  保证不同线程对这个共享变量的可见性，即一个线程改变了共享变量的值，这个新值对其他线程来说是立即可见的。
  Java的内存模型规定所有的变量存储在主内存中，每条线程还有自己的工作内存，线程的工作内存中保存了被该线程所使用到的变量（这些变量是从主内存中拷贝而来）。线程对变量的所有操作（读取，赋值）都必须在工作内存中进行。不同线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成。

  因为执行线程必须先在自己的工作缓存中进行赋值操作，然后再写入主存，而不是直接写入主存。这样就会出现缓存不一致的问题，一个线程对共享变量进行修改之后，还未写入主存，其他线程是不可见的，读出的值可能依然是旧值，即多线程编程中的脏读。
  而当使用volatile关键字之后，被修饰的共享变量被修改后会立即写入主存，并导致该变量在其他线程中的缓存失效，从而致使其他线程再次读取该变量时会从主存中读取。即一个线程改变了共享变量的值，这个新值对其他线程来说是立即可见的。

三、使用interrupt()中断的方式

  （1）线程处于阻塞状态，如使用了sleep方法。当调用interrupt()时，会抛出InterruptException异常。可以在代码中捕获这个异常，然后break跳出循环，从而退出run()方法，结束线程。

public class ThreadSafe extends Thread {
    public void run() {
        while (true) {
            try {
                Thread.sleep(5*1000); // 阻塞5秒
            } catch(InterruptedException e) {
                e.printStackTrace();
                break; // 捕获到异常后，执行break跳出循环
            }
        }
    }
}

  （2）线程未处于阻塞状态，使用isInterrupted()来判断线程的中断标志来退出循环。当使用interrupt()方法时，isInterrupted()就会返回true，和使用自定义的标志位控制循环是一样的原理。

public class ThreadSafe extends Thread {
    public void run() {
        while (!isInterrupted()) {
            // do something
        }
    }
}

  （3）值得注意的是，对阻塞状态的线程使用interrupt()，会抛出Interrupted Exception异常，还会将中断位先置为true再复位为false，如果此时不通过break退出线程，那么等到线程变为运行状态之后，再通过isInterrupted()获得的中断位将是false，无法退出线程。所以使用interrupt()来退出线程的最好的方式应该是两种情况都要考虑：

public class ThreadSafe extends Thread {
    public void run() {
        while (!isInterrupted()) { // 非阻塞状态时通过判断中断标志来退出
            try {
                Thread.sleep(5*1000); // 阻塞5秒
            } catch(InterruptedException e) { // 阻塞状态下通过捕获中断异常来退出
                e.printStackTrace();
                break;
            }
        }
    }
}

  这样不管线程当前处于运行状态或是阻塞状态，执行interrupt()方法后都会退出。