Thread.stop, Thread.suspend, Thread.resume 和Runtime.runFinalizersOnExit 这些终止线程运行的方法已经被废弃，使用它们是极端不安全的！

现在，如果要安全有效地终止一个线程，应该采用以下这些方法：

1，线程正常执行完毕，正常结束。

也就是让run方法执行完毕，该线程就会正常结束。

2，监视某些条件，结束线程的不间断运行。

通过自己加入一个成员变量, 我们在程序的循环里面, 轮流的去检查这个变量,  变量变化时,就会退出这个线程.如:

public class StopThread extends Thread

{

private boolean _run = true;
public void stopThread(boolean run) 

{

this._run = !run;
}

@Override
public void run()

 {
while(_run) 

{
///
// 数据处理

     }
//super.run();

}

public static void main(String[] args)

 {
StopThread thread = new StopThread();
thread.start();
try {
     Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
//停止线程
        thread.stopThread(true);

}
我们可以在while死循环内，每次循环时，察看外部条件，看看是否需要关闭当前线程。

如果是，就break，跳出死循环，或者是抛出异常，跳出死循环，结束线程。

3，带阻塞函数的进程中断

有些执行伺服任务的线程，在while(true)这样的死循环内部，是一个阻塞中的方法。此时，就不能采用第二种方法了。因为，当该方法没有返回时，该线程一直处于阻塞当中，如果线程被阻塞，它便不能核查共享变量，无法执行其他语句，也就不能停止。所以，要使用某种机制使得线程更早地退出被阻塞的状态。这个时候你可以使用Thread.interrupt();

产生一个InterruptedException运行时异常，使阻塞中的那个方法抛出这个异常，从而让我们有机会结束这个线程的执行。

public class BlockTask extends Thread {
    @Override
    public void run() {
        try {
            while (!Thread.interrupted()) {
                   
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
       
    }
}

但是上面的代码或许有些不妥，或许用例子更能把问题说清楚。你怎么知道该代码段会发生阻塞？interrupt()函数到底是什么意思呢？首先说明的是，interrupted（）方法只能解决跑出InterruptedException异常的阻塞。而interrupt()并不是关闭阻塞线程，而且解除阻塞。那这里就举出一个关闭线程阻塞的例子：

public class BlockTask extends Thread {
 2     @Override
 3     public void run() {
 4         try {
 5             sleep(10000);
 6         } catch (InterruptedException e) {
 7             System.out.println("if yout use interrupt you will see me");
 8         }
 9        
10     }
11     public static void main(String[] args)throws Exception {
12         // TODO Auto-generated method stub
13         BlockTask task = new BlockTask();
14         task.start();
15         Thread.sleep(1000);
16         task.interrupt();
17        
18     }
19 }

上面说了，interrupt()只能解决InterruptedException的阻塞的线程，那么遇到一些其他的io阻塞怎么处理呢？这个时候java都会提供相应的关闭阻塞的办法。例如，服务器可能需要等待一个请求（request），又或者，一个网络应用程序可能要等待远端主机的响应,这个时候可以使用套接字close()方法

public class SocketTask extends Thread {
 2     private volatile ServerSocket server;
 3    
 4     public void stopTask(){
 5         try {
 6             if(server!=null){
 7                 server.close();
 8                 System.out.println("close task successed");
 9             }
10         } catch (IOException e) {
11             System.out.println("close task failded");
12         }
13     }
14     @Override
15     public void run() {
16         try {
17             server = new ServerSocket(3333);
18         } catch (IOException e) {
19             e.printStackTrace();
20         }
21     }
22    
23     public static void main(String[] args) throws InterruptedException {
24        
25         SocketTask task = new SocketTask();
26         task.start();
27         Thread.sleep(1000);
28         task.stopTask();
29     }
30
31 }

4，捕获InterruptedException 运行时异常，中断当前线程。

有些执行伺服任务的线程，在while(true)这样的死循环内部，是一个阻塞中的方法。此时，就不能采用第二种方法了。因为，当该方法没有返回时，该线程一直处于阻塞当中，根本无法执行其他语句。

此时，就需要调用该线程的interrupt方法，产生一个InterruptedException运行时异常，是阻塞中的那个方法抛出这个异常，从而让我们有机会结束这个线程的执行

 @Override

    publicvoid run() {

while(true){

           try {

// getSendMessages 是BlockingQueue类。它的take方法将会阻塞！

              responseMessage = this.getSendMessages().take();

           } catch(InterruptedException e1) {

              thrownewRuntimeException();

//或者break;

           }

           someWork();

    }

一个外部的Thread 对象指向这个线程。 需要结束这个线程时，只需要调用thread对象的interrupt() 方法，就会在

responseMessage = this.getSendMessages().take();

这条语句中产生一个InterruptedException异常，从而结束该线程的阻塞状态，通过抛出异常，或者break跳出死循环，结束这个线程

最后，Android 在自己的Api中加入了Process类, 这个类可以直接终结进程, 也就是当前线程所在的JVM. final static void killProcess(int pid)  其中pid, 可以通过Process.mypid() 获取, 但这样终结的是整个程序, 不是我们所想要的。