java - 关于线程的停止

Question

我开发了一个代码，在执行时会启动两个线程

public class MyThread1 extends Thread //extend thread class 
{
    // public  synchronized void run()
     //synchronized (this)

     public   void run()
    {//synchronized(this)
        //{
         for(int i=0;i<20;++i) {
             try{
                 Thread.sleep(500);


          System.out.print(i +"\n"+ "..");
             }catch(Exception e)
             {e.printStackTrace();}
          //} 
        }

     }  

 public static void main(String... a) 
 {
     MyThread1 t = new MyThread1();

     Thread x = new Thread(t);

     Thread y = new Thread(t);
     x.start();
     y.start();

     }

现在它启动了两个线程但是如果我想停止一个特定的线程怎么办，假设我想停止线程 Y 那么我将如何做请告知因为停止线程意味着它的运行方法已完成但我想要要强行阻止它我将如何做到这一点，请指教

Answer 1

免责声明:此答案具有教程性质。

基本方法:我们最初保持简单，不处理 Thread.sleep 方法期间的中断。本质上，您应该有一个外部可设置的变量，run 方法会在循环的每次迭代中检查该变量；然后您可以设置该变量以优雅地终止 run() 方法。请注意这个习语如何可以轻松地用于 Java 以外的语言。

例如:

public class MyThreadedClass extends Thread {

  private volatile boolean completed = false;

  public void setCompleted() {
    this.completed = true;
  }

  public void run()
  {
    while (!completed) {
      // do anything you fashion
    }
  } 

  public static void main(String... args) 
  {
    MyThreadedClass x = new MyThreadedClass();
    MyThreadedClass y = new MyThreadedClass();

    x.start();
    y.start();

    x.setCompleted(); // will complete as soon as the latest iteration finishes

    ...
  }
}

COMMENTS:volatile 标志告诉编译器 completed 可能(并且将会)在 run() 函数的控制之外被更改，即另一个线程可能会改变它。否则循环中的迭代检查可能会根据类的唯一同步行为被错误地优化。

在您的特定 run() 案例中，我们利用了 for 循环，因此我们的方法转化为以下内容:

public void run()
{
  try {
    for(int i=0;i<20 && !completed;++i) {        
      Thread.sleep(500);
      System.out.print(i +"\n"+ "..");
    } 
  } catch(Exception e) {
    e.printStackTrace();
  }
}

评论:很明显，由于 sleep 调用，您可能需要等待长达 500 毫秒。但是，一般来说，如果您的代码必须执行改变变量状态的操作(特别是，如果这些变量在多个线程之间共享!)，那么您就不会让这些变量处于不正确的状态。实际上，您可以正确处理事务，因为您可以控制终止。这显然假设，在循环的每次迭代结束时，变量状态是一致的。

现在让我们改进在 Thread.sleep 期间处理中断的基本方法。

完整答案:从调用方来看，这个答案涉及 Thread.interrupt() 方法的使用，这使得该方法严格特定于 Java。

public class MyThreadedClass extends Thread {

  public void run()
  {
    try {
      for(int i=0;i<20 && !this.isInterrupted();++i) {        
        Thread.sleep(500);
        System.out.print(i +"\n"+ "..");
        ...
        // some molassy slow code here, where you may sprinkle isInterrupted()
        // checks and consequent break statements 
      } 
    } catch(InterruptedException e) {
      // do whatever you need to clean things up
    } catch(Exception e) {
      // handle other exceptions as seen fit
    }
  }

  public static void main(String... args) 
  {
    MyThreadedClass x = new MyThreadedClass();

    x.start();

    // will complete 
    // a) as soon as one isInterrupted() check breaks the loop, or 
    // b) "immediately" during the blocking call to sleep()
    x.interrupt(); 

    ...
  }
}

评论:在这种情况下，Thread 本身已经完成了一半的工作。如果您只需要在 Thread.sleep 调用期间中断，那么除了处理 InterruptedException 以清理您的状态外，您无需执行任何其他操作(如有必要)。相反，如果您需要在“慢速”代码期间中断，则必须在您喜欢的任何地方(可能在多个地方)调用 this.isInterrupted() 并中断循环；循环条件内的调用很常见但不是必需的。

更多信息可以在 Java 并发 Interrupts tutorial 中找到.