# Interface ThreadReference

public interface ThreadReference
Hot code replacement extension to `com.sun.jdi.ThreadReference`.

## Method Summary

Modifier and Type
Method
Description
`boolean`
`doReturn(Value returnValue, boolean triggerFinallyAndSynchronizedBlocks)`
Resumes the execution of this thread as if the next instruction was a return instruction with the given value.

## Method Details

### doReturn

boolean doReturn(Value returnValue, boolean triggerFinallyAndSynchronizedBlocks)
Resumes the execution of this thread as if the next instruction was a return instruction with the given value. This causes the top stack frame to be popped with the given value.

A breakpoint instruction at the current instruction is not triggered that is, this operation takes precedence over breakpoints. `try-finally` blocks enclosing the current location will be triggered in due course.

The triggerFinallyAndSynchronizedBlocks option on this operation controls whether `try-finally` and `synchronized` blocks enclosing the current location should be triggered:

- If no, the stack frame is popped, the return value is returned, and execution continues back in the caller. Note that `finally` blocks are not run, and that if the code is nested within a `synchronized` statement, the monitor lock is not released (however, if the method is `synchronized` the monitor lock will be properly released). This mechanism is sure-fire, but at the risk of not letting the target program clean itself up (e.g., close its files).
- If yes, the VM checks to see whether there might be a `finally` or `synchronized` block enclosing the current instruction.
  - If there is no enclosing `finally` block, the operation reduces to the above case.ll
  - If there is an enclosing `finally` block, the VM creates a VM exception and activates the `finally` block with it. If this exception eventually causes the stack frame to be popped, the exception is caught by the VM itself, the return value is returned, and execution continues back in the caller.

Note that a `finally` block manifests itself as (and is indistinguishable from) a `catch Throwable` block. `synchronized` statements also compile to a `catch Throwable` block. The target program may inadventently end up catching this exception. Since the choices each have their pros and cons, making the decision is left to the debugger. However the later option is the recommended choice.
The reply to the operation contains a flag indicating whether any `finally` or `synchronized` blocks are enclosing the current instruction.
This operation is ignored if the thread was not suspended. If the thread was suspended multiple times, wait for the same number of resumes before executing the return instruction.
The returned value is ignored if the method returns void.
Throws an `OperationRefusedException` if the VM refused to perform this operation. This in recognition that the VM may be in an awkward state and unable to comply:

- for example, execution is suspended in a native method,
- for example, execution is suspended during class preparation.

Parameters:
  `returnValue` - the value to return from the thread with
  `triggerFinallyAndSynchronizedBlocks` - if finally / synchronization blocks should be executed before resuming
Returns:
  if the forced return was successful