在 Android Studio 中，我有一个线程包含在这样的方法中(如下所示)，因为我想在调用时重新启动线程[1]，(重新创建线程而不是重新启动)

public void callthread(){

   final Thread myThread = new Thread(new Runnable()
   {
       @Override
       public void run()
       {
           for (int x=0; x<750&&!Thread.interrupted(); x++) {
               //using this and thread sleep for repeated timed code within a thread

               try {
                   Thread.sleep(4);
                   runOnUiThread(new Runnable()
                   {
                       @Override
                       public void run() {

                           //some code

                           if (condition) {      
                               myThread.interrupt();
                           }
                       }
                   });

               } catch (InterruptedException e) {

               }
           }
       }
   });

我的问题是它不允许我在代码中的所需位置使用 myThread.interrupt();，给我一个错误提示“变量‘myThread’可能尚未初始化”并且不会因此而编译。但是，当整个线程都包含在类中但我没有办法重新启动它时它会起作用。换句话说，我需要一种方法来中断包含在方法中的线程。[2]

接受的解决方案

[1]。 可以重启线程的解决方案

[2]。 线程包含在方法中时可以中断线程的解决方案

PS:如果不清楚，我已经编辑了上面的代码以便于阅读，但我没有像我假设的那样删除 for 循环或 Thread.sleep 之类的东西他们可能是问题的一部分。因此，如果某个花括号太多或太少，那都不是问题

编辑:四处搜索，显然你不能重新启动一个线程

最佳答案

您可以在进入 for 循环之前在 myThread 中启动中断线程。中断线程 hibernate 5 秒，然后中断 myThread。中断在异常处理程序中处理。循环变量 x 被重置为 0，这实际上是循环的重新启动。

public class ThreadInterruptRestart {

    public static void main(String[] args) {
        new ThreadInterruptRestart().callthread();
    }

    public void callthread() {

        final Thread myThread = new Thread("myThread") {
            @Override
            public void run() {
                final Thread _this = this;

                Thread interruptingThread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(5000);
                        } catch (InterruptedException e) {
                            // this is not the interrupt we are interested in
                            e.printStackTrace();
                        }
                        if (true) {
                            System.out.println("interrupting " + _this + " from thread " + this);
                            _this.interrupt();
                        }
                    }
                }, "interrupting thread");
                interruptingThread.start();

                for (int x = 0; x < 750; x++) {
                    // using this and thread sleep for repeated timed code
                    // within a thread
                    try {
                        System.out.println(x);
                        Thread.sleep(10);
                    } catch (InterruptedException e1) {
                        // this is the interrupt we want to handle
                        System.out.println("" + this + " interrupted!");
                        // reset the loop counter
                        x = 0;
                    }
                }
            }
        };
        myThread.start();
    }
}

还有另一个版本，其中 myThread 不 hibernate ，并且使用同步而不是 InterruptedException:

public class ThreadInterruptRestart {

    public static void main(String[] args) {
        new ThreadInterruptRestart().callthread();
    }

    public void callthread() {

        final Object mutex = new Object();

        final Thread myThread = new Thread("myThread") {
            @Override
            public void run() {
                final Thread _this = this;

                Thread interruptingThread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            // this is not the interrupt we are interested in
                            e.printStackTrace();
                        }
                        if (true) {
                            System.out.println("interrupting " + _this + " from thread " + this);
                            synchronized (mutex) {
                                _this.interrupt();
                            }
                        }
                    }
                }, "interrupting thread");
                interruptingThread.start();

                for (int x = 0; x < 75000; x++) {
                    // using this and thread sleep for repeated timed code
                    // within a thread
                    synchronized (mutex) {
                        System.out.println(x);
                        // do other stuff here
                    }
                    if (Thread.interrupted()) {
                        // this is the interrupt we want to handle
                        System.out.println("" + this + " interrupted!");
                        // reset the loop counter
                        x = 0;
                    }
                }
            }
        };
        myThread.start();
    }
}

关于java - Android:方法中包含的中断线程，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31930130/