线程结束的方式

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 {
      @Override
      public void run() {
          try {
              sleep(10000);
          } catch (InterruptedException e) {
              System.out.println("if yout use interrupt you will see me");
          }
        
     }
     public static void main(String[] args)throws Exception {
         // TODO Auto-generated method stub
         BlockTask task = new BlockTask();
         task.start();
         Thread.sleep(1000);
         task.interrupt();
        
     }
 }

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

public class SocketTask extends Thread {
      private volatile ServerSocket server;
     
      public void stopTask(){
          try {
              if(server!=null){
                  server.close();
                  System.out.println("close task successed");
              }
         } catch (IOException e) {
             System.out.println("close task failded");
         }
     }
     @Override
     public void run() {
         try {
             server = new ServerSocket(3333);
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
    
     public static void main(String[] args) throws InterruptedException {
        
         SocketTask task = new SocketTask();
         task.start();
         Thread.sleep(1000);
         task.stopTask();
     }

 }

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