java - 如何从监视器线程中断另一个线程

Question

我知道这是不明智的，但我仍然试图研究一种方法来中断另一个正在计时的线程中挂起的线程。

我所做的是: 我在可疑的网络操作即将发生之前启动监视器线程。该线程应该监视自启动以来耗时，如果时间超过某个阈值，它就会杀死最初启动它的线程。为了通知这个新线程，哪个线程要被杀死，新线程的对象被传递一个要监视的线程的对象。

简而言之，这就是发生的事情:

A创建B，B创建C，B告诉C关于它自己的信息，C保持时间，如果时间到期，C杀死B(我在B的run方法中使用“currentThread()”将详细信息传递给C，并且我已经确认确实正在传递正确的对象)

现在的问题是，这不起作用，由于某种原因，对 B.interrupt() 的调用正在杀死 C 本身。

[注意:大写字母表示线程名称]

Answer 1

我认为您的代码有问题(除非我没有正确理解您的规范)。下面的代码按预期运行(抱歉可怕的嵌套结构):

输出为:

C is about to interrupt B
B is interrupted
C is still alive... is B alive yet?false

代码是:

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicReference;


public class Scrap {
    public static void main(String[] args) {
        Thread A = new Thread() {
            @Override
            public void run() {
                Thread B = new Thread() {
                    @Override
                    public void run() {
                        final CountDownLatch latch = new CountDownLatch(1);
                        final AtomicReference<Thread> pointer = new AtomicReference<Thread>();
                        Thread C = new Thread() {
                            @Override
                            public void run() {
                                try {
                                    //wait for B to be ready
                                    latch.await();
                                    Thread.sleep(2000);
                                    System.out.println("C is about to interrupt B");
                                    pointer.get().interrupt();
                                    Thread.sleep(2000);
                                    System.out.println("C is still alive... is B alive yet? " + pointer.get().isAlive());

                                } catch (InterruptedException e) {
                                    System.out.println("C interrupted");
                                    return;
                                }
                            }
                        };//C
                        C.start();
                        latch.countDown();
                        //Not sure how you did it, so just going with this:
                        pointer.set(Thread.currentThread());


                        try {
                            Thread.sleep(5000);
                        } catch (InterruptedException e) {
                            System.out.println("B is interrupted");
                            return;
                        }
                        System.out.println("B survived");

                    }
                };//B
                B.start();
            }
        };
        A.start();
    }
}

我(疯狂)的猜测是线程间可见性。在上面的代码中，我使用原子引用来确保可见性。如果您没有这样做，则您传递给线程 B 的引用(值)的任何字段都可能对 C 不可见。然后，当 C 尝试中断此 Thread 对象时，它会看到 null，并且中断结果为 NullPointerExceptin ，不知何故你没有注意到它？