static final int THREAD_STATUS_UNKNOWN

Thread status is unknown

static final int THREAD_STATUS_ZOMBIE

Thread has completed execution

static final int THREAD_STATUS_RUNNING

Thread is runnable

static final int THREAD_STATUS_SLEEPING

Thread is sleeping - Thread.sleep(long).

static final int THREAD_STATUS_MONITOR

Thread is waiting on a java monitor

static final int THREAD_STATUS_WAIT

Thread is waiting - Object.wait() or LockSupport.park(). A virtual thread that is sleeping in Thread.sleep(long) may have this thread status instead of THREAD_STATUS_SLEEPING.

static final int THREAD_STATUS_NOT_STARTED

Thread has not yet been started

String name()

Returns the name of this thread.

void suspend()

Suspends this thread. The thread can be resumed through resume() or resumed with other threads through VirtualMachine.resume().

Suspends of both the virtual machine and individual threads are counted. Before a thread will run again, it must be resumed (through resume() or VirtualMachine.resume()) the same number of times it has been suspended.

Suspending single threads with this method is inherently deadlock-prone. If the suspended thread holds a monitor needed by another running thread, deadlock is possible in the target VM (at least until the suspended thread is resumed again).

The suspended thread is guaranteed to remain suspended until resumed through one of the JDI resume methods mentioned above.

void resume()

Resumes this thread. If this thread was not previously suspended through suspend() or through VirtualMachine.suspend(), or because of a SUSPEND_ALL or SUSPEND_EVENT_THREAD event, then invoking this method has no effect. Otherwise, the count of pending suspends on this thread is decremented. If it is decremented to 0, the thread will continue to execute. Note: the normal way to resume from an event related suspension is via EventSet.resume().

int suspendCount()

Returns the number of pending suspends for this thread. See suspend() for an explanation of counted suspends.

void stop(ObjectReference throwable) throws InvalidTypeException

Stops this thread with an asynchronous exception. A debugger thread in the target VM will stop this thread with the given Throwable object.

This method may be used to send an asynchronous exception to a virtual thread when it is suspended at an event. An implementation may support sending an asynchronous exception to a suspended virtual thread in other cases.

void interrupt()

Interrupts this thread unless the thread has been suspended by the debugger.

int status()

Returns the thread's status. If the thread is not suspended the thread's current status is returned. If the thread is suspended, the thread's status before the suspension is returned (or THREAD_STATUS_UNKNOWN if this information is not available. isSuspended() can be used to determine if the thread has been suspended.

boolean isSuspended()

Determines whether the thread has been suspended by the the debugger.

boolean isAtBreakpoint()

Determines whether the thread is suspended at a breakpoint.

ThreadGroupReference threadGroup()

Returns this thread's thread group.

int frameCount() throws IncompatibleThreadStateException

Returns the number of stack frames in the thread's current call stack. The thread must be suspended (normally through an interruption to the VM) to get this information, and it is only valid until the thread is resumed again.

List<StackFrame> frames() throws IncompatibleThreadStateException

Returns a List containing each StackFrame in the thread's current call stack. The thread must be suspended (normally through an interruption to the VM) to get this information, and it is only valid until the thread is resumed again.

StackFrame frame(int index) throws IncompatibleThreadStateException

Returns the StackFrame at the given index in the thread's current call stack. Index 0 retrieves the current frame; higher indices retrieve caller frames. The thread must be suspended (normally through an interruption to the VM) to get this information, and it is only valid until the thread is resumed again.

List<StackFrame> frames(int start, int length) throws IncompatibleThreadStateException

Returns a List containing a range of StackFrame mirrors from the thread's current call stack. The thread must be suspended (normally through an interruption to the VM) to get this information, and it is only valid until the thread is resumed again.

List<ObjectReference> ownedMonitors() throws IncompatibleThreadStateException

Returns a List containing an ObjectReference for each monitor owned by the thread. A monitor is owned by a thread if it has been entered (via the synchronized statement or entry into a synchronized method) and has not been relinquished through Object.wait().

Not all target virtual machines support this operation. Use VirtualMachine.canGetOwnedMonitorInfo() to determine if the operation is supported.

List<MonitorInfo> ownedMonitorsAndFrames() throws IncompatibleThreadStateException

Returns a List containing a MonitorInfo object for each monitor owned by the thread. A monitor is owned by a thread if it has been entered (via the synchronized statement or entry into a synchronized method) and has not been relinquished through Object.wait().

Not all target virtual machines support this operation. Use VirtualMachine.canGetMonitorFrameInfo() to determine if the operation is supported.

ObjectReference currentContendedMonitor() throws IncompatibleThreadStateException

Returns an ObjectReference for the monitor, if any, for which this thread is currently waiting. The thread can be waiting for a monitor through entry into a synchronized method, the synchronized statement, or Object.wait(). The status() method can be used to differentiate between the first two cases and the third.

Not all target virtual machines support this operation. Use VirtualMachine.canGetCurrentContendedMonitor() to determine if the operation is supported.

void popFrames(StackFrame frame) throws IncompatibleThreadStateException

Pop stack frames.

All frames up to and including the frame are popped off the stack. The frame previous to the parameter frame will become the current frame.

After this operation, this thread will be suspended at the invoke instruction of the target method that created frame. The frame's method can be reentered with a step into the instruction.

The operand stack is restored, however, any changes to the arguments that occurred in the called method, remain. For example, if the method foo:

    void foo(int x) {
        System.out.println("Foo: " + x);
        x = 4;
        System.out.println("pop here");
    }
 

was called with foo(7) and foo is popped at the second println and resumed, it will print: Foo: 4.

Locks acquired by a popped frame are released when it is popped. This applies to synchronized methods that are popped, and to any synchronized blocks within them.

Finally blocks are not executed.

No aspect of state, other than this thread's execution point and locks, is affected by this call. Specifically, the values of fields are unchanged, as are external resources such as I/O streams. Additionally, the target program might be placed in a state that is impossible with normal program flow; for example, order of lock acquisition might be perturbed. Thus the target program may proceed differently than the user would expect.

This thread must be suspended.

All StackFrame objects for this thread are invalidated.

This method may be used to pop frames of a virtual thread when it is suspended at an event. An implementation may support popping the frames of a suspended virtual thread in other cases.

No events are generated by this method.

None of the frames through and including the frame for the caller of frame may be native.

Not all target virtual machines support this operation. Use VirtualMachine.canPopFrames() to determine if the operation is supported.

void forceEarlyReturn(Value value) throws InvalidTypeException, ClassNotLoadedException, IncompatibleThreadStateException

Force a method to return before it reaches a return statement.

The method which will return early is referred to as the called method. The called method is the current method (as defined by the Frames section in the Java Virtual Machine Specification) for the specified thread at the time this method is called.

The thread must be suspended. The return occurs when execution of Java programming language code is resumed on this thread. Between the call to this method and resumption of thread execution, the state of the stack is undefined.

This method may be used to force a return from the current frame of a virtual thread when it is suspended at an event. An implementation may support forcing a return from the current frame of a suspended virtual thread in other cases.

No further instructions are executed in the called method. Specifically, finally blocks are not executed. Note: this can cause inconsistent states in the application.

A lock acquired by calling the called method (if it is a synchronized method) and locks acquired by entering synchronized blocks within the called method are released. Note: this does not apply to native locks or java.util.concurrent.locks locks.

Events, such as MethodExit, are generated as they would be in a normal return.

The called method must be a non-native Java programming language method. Forcing return on a thread with only one frame on the stack causes the thread to exit when resumed.

The value argument is the value that the method is to return. If the return type of the method is void, then value must be a VoidValue. Object values must be assignment compatible with the method return type (This implies that the method return type must be loaded through the enclosing class's class loader). Primitive values must be either assignment compatible with the method return type or must be convertible to the variable type without loss of information. See JLS section 5.2 for more information on assignment compatibility.

Not all target virtual machines support this operation. Use VirtualMachine.canForceEarlyReturn() to determine if the operation is supported.

default boolean isVirtual()

Returns true if the thread is a virtual thread.