如何中止 com.sun.jdi.ObjectReference 上长时间运行的 invokeMethod？

问题描述 投票：0回答：2

我有自己的 JDI 调试器，它在某些对象上调用 

toString
方法：

com.sun.jdi.ObjectReferenceobject object = ...
ThreadReference threadRef = frameProxy.threadProxy().getThreadReference();
Value value = object.invokeMethod(threadRef, toStringMethod,
                    Collections.EMPTY_LIST, ObjectReference.INVOKE_SINGLE_THREADED);

问题是，即使在 toString() 方法内没有设置断点，invokeMethod 也永远不会终止，因此我的调试器会挂起。例如，当我在 

Double
对象上调用此函数时，就会发生这种情况。

如何在一段时间后终止

invokeMethod
的执行？

更新：我尝试实现自己的

Double
对象，并在
System.out.println()
方法的开头和结尾放置一些
toString()
语句，看起来该方法执行得很好，但由于某种原因调试器没有执行t 收到结果。也许这是 JDI 中的一个错误，因为有很多这样的错误，但我不是为此寻找解决方案，我只是在寻找一种方法来中止
invokeMethod()
的执行（如果需要太多时间）。

Update2：我尝试了ThierryB的建议，但我只能在管理器线程中调用

frameProxy.threadProxy().stop(object);
。并且管理器线程由于
invokeMethod()
而被阻塞，因此它不会执行我的命令。我尝试过这样的事情：

boolean[] isFinished = new boolean[2];
isFinished[0] = false;

DebuggerManagerThreadImpl managerThread = debugProcess.getManagerThread();
new Thread(() - > {
    try {
        Thread.sleep(2000);
        if (!isFinished[0]) {
            System.out.println("Invoked");
            managerThread.invokeCommand(new DebuggerCommand() {
                @Override
                public void action() {
                    try {
                        frameProxy.threadProxy().stop(object);
                    } catch (InvalidTypeException e) {
                        e.printStackTrace();
                    }
                    int threadStatus = frameProxy.threadProxy().status();
                    switch (threadStatus) {
                        case ThreadReference.THREAD_STATUS_RUNNING:
                            System.out.println("The thread is running.");
                            break;
                        case ThreadReference.THREAD_STATUS_ZOMBIE:
                            System.out.println("The thread has been completed.");
                            break;
                        case ThreadReference.THREAD_STATUS_WAIT:
                            System.out.println("The thread is waiting.");
                            break;
                        default:
                            System.out.println("The thread is not running / not waiting / not completed : but what is it doing right now ? (a little programmer joke ;) )");
                    }
                }

                @Override
                public void commandCancelled() {

                }
            });
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

Value value = object.invokeMethod(threadRef, toStringMethod,
    Collections.EMPTY_LIST, ObjectReference.INVOKE_SINGLE_THREADED);

isFinished[0] = true;

但是 

frameProxy.threadProxy().stop(object);
永远不会被执行，因为 
DebuggerCommand's
action
方法没有被调用（线程被阻塞）。

这也是我的调试器挂起并且我强行停止该进程时的堆栈跟踪：

com.sun.jdi.VMDisconnectedException
    at com.jetbrains.jdi.TargetVM.waitForReply(TargetVM.java:317)
    at com.jetbrains.jdi.VirtualMachineImpl.waitForTargetReply(VirtualMachineImpl.java:1170)
    at com.jetbrains.jdi.PacketStream.waitForReply(PacketStream.java:86)
    at com.jetbrains.jdi.JDWP$ObjectReference$InvokeMethod.waitForReply(JDWP.java:4840)
    at com.jetbrains.jdi.ObjectReferenceImpl.invokeMethod(ObjectReferenceImpl.java:413)

更新3：使用哪个线程来调用方法？目前我正在使用 

frameProxy.threadProxy().getThreadReference();
，它在大多数情况下都工作得很好，但是最好创建一个单独的线程来调用对象上的方法（沿着我的 JDI 调试器，我在应用程序内还有一个仪器代理，这样我就可以创建一个单独的线程）线程仅用于此用例（也许这可以防止死锁？））。

更新4：目前我使用

SUSPEND_ALL
作为暂停策略，使用
SUSPEND_EVENT_THREAD
会更好吗？

java debugging breakpoints jvmti jdi
2个回答
3
投票

您可以通过方法

ThreadReference
使用接口
void stop(ObjectReference throwable)
。 javadoc api 告诉“通过异步异常停止此线程。”。

try {
    com.sun.jdi.ObjectReferenceobject object = ...
    ThreadReference threadRef = frameProxy.threadProxy().getThreadReference();
    frameProxy.threadProxy().stop(object);
    int threadStatus = frameProxy.threadProxy().status();
    switch(threadStatus) {
         case ThreadReference.THREAD_STATUS_RUNNING :
              log.info("The thread is running.");
              break;
         case ThreadReference.THREAD_STATUS_ZOMBIE :
              log.info("The thread has been completed.");
              break;
         case ThreadReference.THREAD_STATUS_WAIT :
              log.info("The thread is waiting.");
              break;
         default :
              log.info("The thread is not running / not waiting / not completed : but what is it doing right now ? (a little programmer joke ;) )");
    }
} catch (ClassNotLoadedException cnle) {
    // log exception, or display a message...
} catch (IncompatibleThreadStateException itse) {
    // log exception, or display a message...
} catch (InvalidTypeException ite) {
    // log exception, or display a message...
}

当您使用 

status
方法检查线程状态时，您可以找到该值：

  • 线程状态未知
  • 线程_状态_僵尸
  • 线程_状态_运行
  • 线程_状态_睡眠
  • 线程状态监视器
  • 线程状态等待
  • 线程状态未启动

希望您能找到一种方法来使用我在这里提供的东西来完成您需要做的事情。 来自 here 或 Alvin Alexander 网站上发布的以下套件测试的示例也可能有所帮助。

0
投票

object.invokeMethod( ... , toStringMethod, ... INVOKE_SINGLE_THREADED

）

这是一个 X/Y 问题。

您看到的挂起是因为您正在执行

INVOKE_SINGLE_THREADED

，据记录在某些情况下会挂起，正如 javadoc 所说：

可以通过在 options 参数中指定 INVOKE_SINGLE_THREADED 位标志来防止调用期间恢复其他线程；但是，无法防止上述死锁或从死锁中恢复，因此应谨慎使用此选项。

在调试者中调用

toString

 之类的“琐碎”事情可能会（在这些情况下）挂在某些类型的对象上，因为某些（java.*）类被编码为不会通过
toString
“打印”不一致的内部状态，所以他们事先获取监视器锁。根据我的经验，至少 Swing 和 AWT 对象会发生这种情况，但它们可能还有许多其他类型的对象也能做到这一点。

通过这种方式解封装

java.lang.Booleans

 和类似的简单对象是安全的。根据我的经验，当像这样调用它们的
toString
 时，这些不会导致挂起。但是像
StringBuffer
 这样“复杂”的东西有时会因为
toString
 中的监视器锁定而挂起。

如果您只需要

toString

一些简单的对象（上面定义的“简单”），那么一种方法是检查它们的（镜像）类型（在调试器中）。就我个人而言，我会检查不会导致挂起的类的字符串白名单，例如代码如下

String vstr = value.toString(); if (vstr.contains("instance of java.lang.Boolean")) { // safe to call toString via invokeMethod } 
但可能有更优雅的解决方案。

从另一个线程进行延迟打印可能会也可能不会在您关心这些对象的时间/地点捕获它们的状态，因为它们同时可能会发生变化。让事件处理线程在执行 
invokeMethod
 时禁用所有挂起的请求（这是 javadoc 中的另一个建议的解决方法）的缺点是您可能会错过一些事件。所以，我认为这个问题没有通用的解决方法。不过，中止/杀死调试对象线程（这是奖励答案向您展示如何做的）可能是我的解决方法列表中的最后一个。
    

	



    

    


  

  

    
最新问题


  





  

    © www.soinside.com 2019 - 2024. All rights reserved.