线程结束的方式

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() 获取, 但这样终结的是整个程序, 不是我们所想要的。