线程。停止是不赞成的，所以我们如何停止一个线程在Java ?

总是使用中断方法和未来请求取消

当任务响应中断信号时，例如阻塞队列采取方法。

Callable < String > callable = new Callable < String > () {
    @Override
    public String call() throws Exception {
        String result = "";
        try {
            //assume below take method is blocked as no work is produced.
            result = queue.take();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return result;
    }
};
Future future = executor.submit(callable);
try {
    String result = future.get(5, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    logger.error("Thread timedout!");
    return "";
} finally {
    //this will call interrupt on queue which will abort the operation.
    //if it completes before time out, it has no side effects
    future.cancel(true);
}

当任务不响应中断信号时。假设任务执行套接字I/O，不响应中断信号，因此使用上述方法将不会中止任务，future将超时，但取消finally块将没有影响，线程将继续侦听套接字。如果由pool实现，我们可以关闭套接字或在连接时调用close方法。

public interface CustomCallable < T > extends Callable < T > {
    void cancel();
    RunnableFuture < T > newTask();
}

public class CustomExecutorPool extends ThreadPoolExecutor {
    protected < T > RunnableFuture < T > newTaskFor(Callable < T > callable) {
        if (callable instanceof CancellableTask)
            return ((CancellableTask < T > ) callable).newTask();
        else
            return super.newTaskFor(callable);
    }
}

public abstract class UnblockingIOTask < T > implements CustomCallable < T > {
    public synchronized void cancel() {
        try {
            obj.close();
        } catch (IOException e) {
            logger.error("io exception", e);
        }
    }

    public RunnableFuture < T > newTask() {
        return new FutureTask < T > (this) {
            public boolean cancel(boolean mayInterruptIfRunning) {
                try {
                    this.cancel();
                } finally {
                    return super.cancel(mayInterruptIfRunning);
                }
            }

        };
    }
}

线程。停止是不赞成的，所以我们如何停止一个线程在Java ?

总是使用中断方法和未来请求取消

当任务响应中断信号时，例如阻塞队列采取方法。

Callable < String > callable = new Callable < String > () {
    @Override
    public String call() throws Exception {
        String result = "";
        try {
            //assume below take method is blocked as no work is produced.
            result = queue.take();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return result;
    }
};
Future future = executor.submit(callable);
try {
    String result = future.get(5, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    logger.error("Thread timedout!");
    return "";
} finally {
    //this will call interrupt on queue which will abort the operation.
    //if it completes before time out, it has no side effects
    future.cancel(true);
}

当任务不响应中断信号时。假设任务执行套接字I/O，不响应中断信号，因此使用上述方法将不会中止任务，future将超时，但取消finally块将没有影响，线程将继续侦听套接字。如果由pool实现，我们可以关闭套接字或在连接时调用close方法。

public interface CustomCallable < T > extends Callable < T > {
    void cancel();
    RunnableFuture < T > newTask();
}

public class CustomExecutorPool extends ThreadPoolExecutor {
    protected < T > RunnableFuture < T > newTaskFor(Callable < T > callable) {
        if (callable instanceof CancellableTask)
            return ((CancellableTask < T > ) callable).newTask();
        else
            return super.newTaskFor(callable);
    }
}

public abstract class UnblockingIOTask < T > implements CustomCallable < T > {
    public synchronized void cancel() {
        try {
            obj.close();
        } catch (IOException e) {
            logger.error("io exception", e);
        }
    }

    public RunnableFuture < T > newTask() {
        return new FutureTask < T > (this) {
            public boolean cancel(boolean mayInterruptIfRunning) {
                try {
                    this.cancel();
                } finally {
                    return super.cancel(mayInterruptIfRunning);
                }
            }

        };
    }
}

在用Java开发了15年之后，有一件事我想对世界说。

弃用Thread.stop()和所有反对其使用的神圣之战只是另一个坏习惯或设计缺陷不幸成为现实…(如。想谈谈Serializable接口吗?)

争论的焦点在于，杀死线程会使对象处于不一致的状态。所以呢?欢迎来到多线程编程。你是一个程序员，你需要知道你在做什么，是的。杀死线程会使对象处于不一致状态。如果你担心它使用一个标志，让线程优雅地退出;但有很多时候，我们没有理由担心。

但没有. .如果你输入thread.stop()，你很可能会被所有查看/注释/使用你代码的人杀死。所以你必须使用一个标志，调用interrupt()，在你的代码周围放置if(!标志)，因为你根本没有循环，最后祈祷你用来进行外部调用的第三方库是正确编写的，并且没有不正确地处理InterruptException。

一种方法是设置一个类变量并将其用作哨兵。

Class Outer {
    public static volatile flag = true;

    Outer() {
        new Test().start();
    }
    class Test extends Thread {

        public void run() {
            while (Outer.flag) {
                //do stuff here
            }
        }
    }

}

设置一个外部类变量，如上面例子中的flag = true。将其设置为false以“杀死”线程。

一般来说你不会…

你可以使用Thread.interrupt() (javadoc link)命令它中断正在做的事情。

在javadoc中有一个很好的解释(java technote链接)

在Java中，线程不会被杀死，但是线程的停止是通过协作的方式完成的。线程被要求终止，然后线程可以优雅地关闭。

通常使用一个易失性布尔字段，线程定期检查，并在设置为相应值时终止。

我不会使用布尔值来检查线程是否应该终止。如果你使用volatile作为字段修饰符，这将可靠地工作，但如果你的代码变得更复杂，而不是在while循环中使用其他阻塞方法，它可能会发生，你的代码根本不会终止，或者至少需要更长的时间。

某些块库方法支持中断。

每个线程已经有一个布尔标志中断状态，你应该利用它。它可以这样实现:

public void run() {
   try {
      while (!interrupted()) {
         // ...
      }
   } catch (InterruptedException consumed)
      /* Allow thread to exit */
   }
}

public void cancel() { interrupt(); }

源代码改编自Java并发实践。因为cancel()方法是公共的，你可以让另一个线程按你的意愿调用这个方法。