线程在调用 stop() 方法时不会停止

Question

我创建了 java Thread 的示例程序，其中我使用 stop() 方法使用以下程序停止线程

public class App extends Thread
{
    Thread th;

    App(String threadName)
    {
        th = new Thread(threadName);
    }

    public synchronized void run() // Remove synchronized
    {
        for (int i = 0; i < 5; i++) {
            System.out.println(th.getName()+" "+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

    public static void main( String[] args ) 
    {
       App thread_1 = new App("Thread-1");
       thread_1.start();
       thread_1.setPriority(MAX_PRIORITY); //Comment this
       thread_1.stop();
       App thread_2 = new App("Thread-2");
       thread_2.start();
    }
}

上述程序的输出是：

Thread-1 0
Thread-1 1
Thread-1 2
Thread-1 3
Thread-1 4
Thread-2 0
Thread-2 1
Thread-2 2
Thread-2 3
Thread-2 4

即thread_1 没有停止。当我删除同步或代码线程中的优先级立即停止并且输出将是

Thread-2 0
Thread-2 1
Thread-2 2
Thread-2 3
Thread-2 4

我无法理解为什么会这样。

Answer 1

Thread 类的大多数公共方法都在 Thread 实例本身上同步。 http://hg.openjdk.java.net/jdk6/jdk6/jdk/file/5672a2be515a/src/share/classes/java/lang/Thread.java

您的 run() 方法在 Thread 实例上同步。 stop()方法调用stop(Throwable)，同样是在Thread实例上同步的，它的签名是：

@Deprecated
public final synchronized void stop(Throwable obj) {

当线程本身仍在您的synchronized run() 方法中运行时，同步会阻止主线程进入thread_1.stop()。

---

这是一个为什么总是使用私有对象进行同步是明智之举的例子。例如，这样做...

class Foobar {
    private final Object lock = new Object();

    public void do_something() {
        synchronized(lock) {
            ...
        }
    }
}

而不是这样做......

class Foobar {
    public synchronized void do_something() {
        ...
    }
}

第二个版本更冗长（欢迎使用 Java！），但它会阻止您的 Foobar 类的用户将其用作同步对象，而这种方式会干扰它自己将自身用作同步对象。

Answer 2

Thread.stop() 已弃用。考虑改用这个：

public class App extends Thread
{
    Thread th;
    volatile boolean bStopThread;
    App(String threadName)
    {
        th = new Thread(threadName);
        bStopThread = false;
    }

    public void stopThread(){
        bStopThread = true;
    }

    public synchronized void run() // Remove synchronized
    {
        for (int i = 0; i < 5; i++) {
            if(bStopThread) return;
            System.out.println(th.getName()+" "+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
        }
    }

    public static void main( String[] args ) throws InterruptedException
    {
       App thread_1 = new App("Thread-1");
       thread_1.start();
       thread_1.setPriority(MAX_PRIORITY); //Comment this
       thread_1.stopThread();
       App thread_2 = new App("Thread-2");
       thread_2.start();
    }
}

它应该可以按你的意愿工作，虽然我还没有测试过。

Answer 3

您的应用程序中有 3 个线程：主线程，运行 main 方法的代码，thread_1 和 thread_2。您的主线程在某个时间点 X 启动 thread_1，然后在某个时间点 Y，Y>X 调用 thread_1.stop()。

现在，点 X 和 Y 之间可能发生的情况是 CPU 调度程序可以决定：“我现在让 thread_1 运行”。 Thread_1 将获得 CPU，将运行并打印他的文本。或者，CPU 调度程序可以决定：“主线程现在正在运行......让它运行”。在调用 stop 之前，thread_1 不会获得 CPU 并且不会打印任何内容。

因此，您对 CPU 调度存在无法控制的不确定性。您只能假设提高线程提示调度程序的优先级以选择上述选项中的第一个。

但是。 stop 已被弃用，所以永远不要使用它。并且不要试图猜测多个线程的执行顺序。

Answer 4

在你的 main 方法中添加一个 try catch。打印堆栈跟踪和捕获的异常消息。在运行方法中相同。然后java会告诉你问题。

MHC 的方法更好，但就像我说的那样 - 有时（很少）当您无法控制线程时，只能调用 stop。但在这种情况下，您确实可以控制它，因此 MHC 方法会很好地工作。

但我看不出您的代码有什么问题 - 它在我的笔记本电脑上运行良好，也许您没有清理并重新编译？更改一些消息，以便您知道最新的代码正在运行

我用过：

package academic.threads;

public class StopThHighPri extends Thread {
    Thread th;
    volatile boolean bStopThread;

    StopThHighPri(String threadName) {
        th = new Thread(threadName);
        bStopThread = false;
    }

    public void stopThread(Thread t) {
        //bStopThread = true;
        try {
            t.stop();
        } catch (Throwable e) {
            System.err.println(" Stop th " + e + " " + e.getMessage());
        }
    }

    public synchronized void run() // Remove synchronized
    {
        try {
            for (int i = 0; i < 5; i++) {
                if (bStopThread)
                    return;
                System.out.println(th.getName() + " " + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("run err " + e);
        }
    }

    public static void main(String[] args) {
        try {
            System.err.println("Code version 002");
            StopThHighPri thread_1 = new StopThHighPri("Thread-1");
            thread_1.start();
            thread_1.setPriority(MAX_PRIORITY); // Comment this
            thread_1.stopThread(thread_1);
            StopThHighPri thread_2 = new StopThHighPri("Thread-2");
            thread_2.start();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("MNain err " + e);
        }
    }
}

输入类似 System.err.println("Code version 002");

并更改 002 、 003。这样您就知道每次编辑课程时最新的代码都在工作。再次学习这是可以的，但不需要在这里使用停止