Add support for JEP491 on JDK24+

fengxue-IS · fengxue-IS · commit 386b6f5c7f41 · 2025-09-16T15:43:20.000-04:00
- Add missing setThreadState
- Fix thread state on notified blocked threads
- Refactor comments

Signed-off-by: Jack Lu &lt;Jack.S.Lu@ibm.com&gt;
diff --git a/runtime/oti/VMHelpers.hpp b/runtime/oti/VMHelpers.hpp
@@ -2278,7 +2278,6 @@ class VM_VMHelpers
 		indicateAsyncMessagePending(targetThread);
 	}
 
-
 	static U_32
 	setThreadState(J9VMThread *currentThread, U_32 state)
 	{
@@ -2289,14 +2288,14 @@ class VM_VMHelpers
 			/* Platform threads must have a non-null FieldHolder object. */
 			j9object_t threadHolder = J9VMJAVALANGTHREAD_HOLDER(currentThread, receiverObject);
 			if (NULL != threadHolder) {
-				oldState = (U_32)J9VMJAVALANGTHREADFIELDHOLDER_THREADSTATUS(currentThread, threadHolder);
+				oldState = J9VMJAVALANGTHREADFIELDHOLDER_THREADSTATUS(currentThread, threadHolder);
 				J9VMJAVALANGTHREADFIELDHOLDER_SET_THREADSTATUS(currentThread, threadHolder, state);
 			}
 		}
 #else /* JAVA_SPEC_VERSION >= 19 */
 		j9object_t receiverObject = currentThread->threadObject;
 		if (NULL != receiverObject) {
-			oldState = (U_32)J9VMJAVALANGTHREAD_THREADSTATUS(currentThread, receiverObject);
+			oldState = J9VMJAVALANGTHREAD_THREADSTATUS(currentThread, receiverObject);
 			J9VMJAVALANGTHREAD_SET_THREADSTATUS(currentThread, receiverObject, state);
 		}
 #endif /* JAVA_SPEC_VERSION >= 19 */
diff --git a/runtime/oti/j9nonbuilder.h b/runtime/oti/j9nonbuilder.h
@@ -5881,18 +5881,25 @@ typedef struct J9VMThread {
 #endif
 #define J9VMTHREAD_ALIGNMENT  0x100
 #define J9VMTHREAD_RESERVED_C_STACK_FRACTION  8
-#define J9VMTHREAD_STATE_RUNNING  1
-#define J9VMTHREAD_STATE_BLOCKED  2
-#define J9VMTHREAD_STATE_WAITING  4
-#define J9VMTHREAD_STATE_SLEEPING  8
-#define J9VMTHREAD_STATE_SUSPENDED  16
-#define J9VMTHREAD_STATE_DEAD  32
-#define J9VMTHREAD_STATE_WAITING_TIMED  64
-#define J9VMTHREAD_STATE_PARKED  0x80
+
+/* J9VMTHREAD_STATE_* bit flags are used to map vmthread state to
+ * j.l.Thread.State in Thread.translateJ9VMThreadStateToThreadState().
+ * Any updates to these value must also update the value used in JCL.
+ *
+ * Note: 0 is reserved for uninitialized case and cannot be used.
+ */
+#define J9VMTHREAD_STATE_RUNNING   0x1
+#define J9VMTHREAD_STATE_BLOCKED   0x2
+#define J9VMTHREAD_STATE_WAITING   0x4
+#define J9VMTHREAD_STATE_SLEEPING  0x8
+#define J9VMTHREAD_STATE_SUSPENDED 0x10
+#define J9VMTHREAD_STATE_DEAD      0x20
+#define J9VMTHREAD_STATE_WAITING_TIMED 0x40
+#define J9VMTHREAD_STATE_PARKED        0x80
 #define J9VMTHREAD_STATE_PARKED_TIMED  0x100
-#define J9VMTHREAD_STATE_INTERRUPTED  0x200
-#define J9VMTHREAD_STATE_UNKNOWN  0x400
-#define J9VMTHREAD_STATE_UNREADABLE  0x800
+#define J9VMTHREAD_STATE_INTERRUPTED   0x200
+#define J9VMTHREAD_STATE_UNKNOWN       0x400
+#define J9VMTHREAD_STATE_UNREADABLE    0x800
 #define J9VMSTATE_MAJOR  0xFFFF0000
 #define J9VMSTATE_MINOR  0xFFFF
 #define J9VMSTATE_INTERPRETER  0x10000
diff --git a/runtime/vm/ObjectMonitor.cpp b/runtime/vm/ObjectMonitor.cpp
@@ -185,7 +185,6 @@ objectMonitorEnterBlocking(J9VMThread *currentThread)
 
 		if (J9_EVENT_IS_HOOKED(vm->hookInterface, J9HOOK_VM_MONITOR_CONTENDED_ENTER)) {
 			bool frameBuilt = saveBlockingEnterObject(currentThread);
-			/* Set j.l.Thread status to BLOCKED. */
 			VM_VMHelpers::setThreadState(currentThread, J9VMTHREAD_STATE_BLOCKED);
 			VM_VMAccess::setPublicFlags(currentThread, J9_PUBLIC_FLAGS_THREAD_BLOCKED);
 			ALWAYS_TRIGGER_J9HOOK_VM_MONITOR_CONTENDED_ENTER(vm->hookInterface, currentThread, monitor);
@@ -199,7 +198,6 @@ objectMonitorEnterBlocking(J9VMThread *currentThread)
 			goto releasedAccess;
 		}
 restart:
-		/* Set j.l.Thread status to BLOCKED. */
 		VM_VMHelpers::setThreadState(currentThread, J9VMTHREAD_STATE_BLOCKED);
 		internalReleaseVMAccessSetStatus(currentThread, J9_PUBLIC_FLAGS_THREAD_BLOCKED);
 releasedAccess:
@@ -290,6 +288,7 @@ objectMonitorEnterBlocking(J9VMThread *currentThread)
 				J9_STORE_LOCKWORD(currentThread, lwEA, lock);
 				goto done;
 			}
+			VM_VMHelpers::setThreadState(currentThread, J9VMTHREAD_STATE_BLOCKED);
 			internalReleaseVMAccessSetStatus(currentThread, J9_PUBLIC_FLAGS_THREAD_BLOCKED);
 			SET_IGNORE_ENTER(monitor);
 			omrthread_monitor_wait_timed(monitor, (I_64)waitTime, 0);
@@ -301,7 +300,6 @@ objectMonitorEnterBlocking(J9VMThread *currentThread)
 		}
 done:
 		clearEventFlag(currentThread, J9_PUBLIC_FLAGS_THREAD_BLOCKED);
-		/* Set j.l.Thread status to RUNNING state. */
 		VM_VMHelpers::setThreadState(currentThread, J9VMTHREAD_STATE_RUNNING);
 
 		/* Clear the SUPPRESS_CONTENDED_EXITS bit in the monitor saying that CONTENDED EXIT can be sent again */
diff --git a/runtime/vm/callin.cpp b/runtime/vm/callin.cpp
@@ -589,7 +589,6 @@ initializeAttachedThreadImpl(J9VMThread *currentThread, const char *name, j9obje
 				currentThread->returnValue = J9_BCLOOP_RUN_METHOD;
 				currentThread->returnValue2 = (UDATA)J9VMJAVALANGTHREAD_INIT_METHOD(vm);
 				c_cInterpreter(currentThread);
-				J9VMJAVALANGTHREAD_SET_STARTED(currentThread, initializee->threadObject, JNI_TRUE);
 #if JAVA_SPEC_VERSION >= 19
 				j9object_t threadHolder = J9VMJAVALANGTHREAD_HOLDER(currentThread, initializee->threadObject);
 				if (NULL != threadHolder) {
@@ -598,6 +597,8 @@ initializeAttachedThreadImpl(J9VMThread *currentThread, const char *name, j9obje
 #else /* JAVA_SPEC_VERSION >= 19 */
 				J9VMJAVALANGTHREAD_SET_THREADSTATUS(currentThread, initializee->threadObject, J9VMTHREAD_STATE_RUNNING);
 #endif /* JAVA_SPEC_VERSION >= 19 */
+				/* Thread.started must be set after Thread.threadStatus to avoid timing issue in Thread.getState(). */
+				J9VMJAVALANGTHREAD_SET_STARTED(currentThread, initializee->threadObject, JNI_TRUE);
 			}
 		}
 done:
diff --git a/runtime/vm/threadhelp.cpp b/runtime/vm/threadhelp.cpp
@@ -118,18 +118,19 @@ monitorWaitImpl(J9VMThread *vmThread, j9object_t object, I_64 millis, I_32 nanos
 #endif
 		J9VMTHREAD_SET_BLOCKINGENTEROBJECT(vmThread, vmThread, object);
 		object = NULL;
-		/* Set j.l.Thread status to WAITING. */
-		U_32 oldState = J9_ARE_ANY_BITS_SET(thrstate, J9_PUBLIC_FLAGS_THREAD_TIMED)
-				? VM_VMHelpers::setThreadState(vmThread, J9VMTHREAD_STATE_WAITING_TIMED)
-				: VM_VMHelpers::setThreadState(vmThread, J9VMTHREAD_STATE_WAITING);
 #if JAVA_SPEC_VERSION >= 24
 		J9VM_SEND_VIRTUAL_UNBLOCKER_THREAD_SIGNAL(javaVM);
 #endif /* JAVA_SPEC_VERSION >= 24 */
+		/* Set j.l.Thread status to UNKNOWN since the wait can be notified/interrupted
+		 * but blocked on re-acquiring the monitor.
+		 * In this case, the thread state will have to be determined by looking at
+		 * the vmThread->publicFlags field.
+		 */
+		U_32 oldState = VM_VMHelpers::setThreadState(vmThread, J9VMTHREAD_STATE_UNKNOWN);
 		internalReleaseVMAccessSetStatus(vmThread, thrstate);
 		rc = timeCompensationHelper(vmThread,
 			interruptable ? HELPER_TYPE_MONITOR_WAIT_INTERRUPTABLE : HELPER_TYPE_MONITOR_WAIT_TIMED, monitor, millis, nanos);
 		internalAcquireVMAccessClearStatus(vmThread, thrstate);
-		/* Set j.l.Thread status to oldState. */
 		VM_VMHelpers::setThreadState(vmThread, oldState);
 		J9VMTHREAD_SET_BLOCKINGENTEROBJECT(vmThread, vmThread, NULL);
 		omrthread_monitor_unpin(monitor, vmThread->osThread);
@@ -203,12 +204,10 @@ threadSleepImpl(J9VMThread *vmThread, I_64 millis, I_32 nanos)
 #endif
 		if (0 == rc) {
 			TRIGGER_J9HOOK_VM_SLEEP(javaVM->hookInterface, vmThread, millis, nanos);
-			/* Set j.l.Thread status to SLEEPING. */
 			U_32 oldState = VM_VMHelpers::setThreadState(vmThread, J9VMTHREAD_STATE_SLEEPING);
 			internalReleaseVMAccessSetStatus(vmThread, J9_PUBLIC_FLAGS_THREAD_SLEEPING);
 			rc = timeCompensationHelper(vmThread, HELPER_TYPE_THREAD_SLEEP, NULL, millis, nanos);
 			internalAcquireVMAccessClearStatus(vmThread, J9_PUBLIC_FLAGS_THREAD_SLEEPING);
-			/* Set j.l.Thread status to oldState. */
 			VM_VMHelpers::setThreadState(vmThread, oldState);
 			TRIGGER_J9HOOK_VM_SLEPT(javaVM->hookInterface, vmThread, millis, nanos, startTicks);
 		}
diff --git a/runtime/vm/threadpark.cpp b/runtime/vm/threadpark.cpp
@@ -98,10 +98,9 @@ threadParkImpl(J9VMThread *vmThread, BOOLEAN timeoutIsEpochRelative, I_64 timeou
 		/* vmThread->threadObject != NULL because vmThread must be the current thread */
 		J9VMTHREAD_SET_BLOCKINGENTEROBJECT(vmThread, vmThread, J9VMJAVALANGTHREAD_PARKBLOCKER(vmThread, vmThread->threadObject));
 		TRIGGER_J9HOOK_VM_PARK(vm->hookInterface, vmThread, millis, nanos);
-		/* Set j.l.Thread status to WAITING. */
 		U_32 oldState = J9_ARE_ANY_BITS_SET(thrstate, J9_PUBLIC_FLAGS_THREAD_TIMED)
-				? VM_VMHelpers::setThreadState(vmThread, J9VMTHREAD_STATE_WAITING_TIMED)
-				: VM_VMHelpers::setThreadState(vmThread, J9VMTHREAD_STATE_WAITING);
+				? VM_VMHelpers::setThreadState(vmThread, J9VMTHREAD_STATE_PARKED_TIMED)
+				: VM_VMHelpers::setThreadState(vmThread, J9VMTHREAD_STATE_PARKED);
 		internalReleaseVMAccessSetStatus(vmThread, thrstate);
 
 		while (1) {
@@ -120,7 +119,6 @@ threadParkImpl(J9VMThread *vmThread, BOOLEAN timeoutIsEpochRelative, I_64 timeou
 		}
 
 		internalAcquireVMAccessClearStatus(vmThread, thrstate);
-		/* Set j.l.Thread status to oldState. */
 		VM_VMHelpers::setThreadState(vmThread, oldState);
 		TRIGGER_J9HOOK_VM_UNPARKED(vm->hookInterface, vmThread, millis, nanos, startTicks, (UDATA) parkedAddress, VM_VMHelpers::currentClass(parkedClass));
 		J9VMTHREAD_SET_BLOCKINGENTEROBJECT(vmThread, vmThread, NULL);
diff --git a/runtime/vm/vmthread.cpp b/runtime/vm/vmthread.cpp
@@ -460,7 +460,6 @@ void threadCleanup(J9VMThread * vmThread, UDATA forkedByVM)
 		/* Safe to call this whether handleUncaughtException clears the exception or not */
 		internalExceptionDescribe(vmThread);
 	}
-	/* Set j.l.Thread status to TERMINATED. */
 	VM_VMHelpers::setThreadState(vmThread, J9VMTHREAD_STATE_DEAD);
 	releaseVMAccess(vmThread);
 
@@ -1924,8 +1923,19 @@ startJavaThread(J9VMThread * currentThread, j9object_t threadObject, UDATA priva
 	privateFlags &= ~J9_PRIVATE_FLAGS_NO_EXCEPTION_IN_START_JAVA_THREAD;
 
 #ifndef J9VM_IVE_RAW_BUILD /* J9VM_IVE_RAW_BUILD is not enabled by default */
+#if JAVA_SPEC_VERSION >= 19
+	j9object_t threadHolder = J9VMJAVALANGTHREAD_HOLDER(currentThread, threadObject);
+	if (NULL != threadHolder) {
+		J9VMJAVALANGTHREADFIELDHOLDER_SET_THREADSTATUS(currentThread, threadHolder, J9VMTHREAD_STATE_RUNNING);
+	}
+#else /* JAVA_SPEC_VERSION >= 19 */
+	J9VMJAVALANGTHREAD_SET_THREADSTATUS(currentThread, threadObject, J9VMTHREAD_STATE_RUNNING);
+#endif /* JAVA_SPEC_VERSION >= 19 */
 	/* Any attempt to start a Thread makes it illegal to attempt to start it again.
-	 * Oracle class libraries don't have the 'started' field */
+	 * Oracle class libraries don't have the 'started' field.
+	 *
+	 * Thread.started must be set after Thread.threadStatus to avoid timing issue in Thread.getState().
+	 */
 	J9VMJAVALANGTHREAD_SET_STARTED(currentThread, threadObject, TRUE);
 #endif /* !J9VM_IVE_RAW_BUILD */
 
@@ -2089,9 +2099,6 @@ startJavaThreadInternal(J9VMThread * currentThread, UDATA privateFlags, UDATA os
 	}
 	J9VMJAVALANGTHREAD_SET_THREADREF(currentThread, threadObject, newThread);
 
-	/* Set j.l.Thread status to RUNNABLE. */
-	VM_VMHelpers::setThreadState(currentThread, J9VMTHREAD_STATE_RUNNING);
-
 #if (JAVA_SPEC_VERSION >= 14)
 	/* If thread was interrupted before start, make sure interrupt flag is set for running thread. */
 	if (J9VMJAVALANGTHREAD_DEADINTERRUPT(currentThread, threadObject)) {

Original file line number	Diff line number	Diff line change
`@@ -2278,7 +2278,6 @@ class VM_VMHelpers`
`2278`	`2278`	`indicateAsyncMessagePending(targetThread);`
`2279`	`2279`	`}`
`2280`	`2280`
`2281`		`-`
`2282`	`2281`	`static U_32`
`2283`	`2282`	`setThreadState(J9VMThread *currentThread, U_32 state)`
`2284`	`2283`	`{`
`@@ -2289,14 +2288,14 @@ class VM_VMHelpers`
`2289`	`2288`	`/* Platform threads must have a non-null FieldHolder object. */`
`2290`	`2289`	`j9object_t threadHolder = J9VMJAVALANGTHREAD_HOLDER(currentThread, receiverObject);`
`2291`	`2290`	`if (NULL != threadHolder) {`
`2292`		`- oldState = (U_32)J9VMJAVALANGTHREADFIELDHOLDER_THREADSTATUS(currentThread, threadHolder);`
	`2291`	`+ oldState = J9VMJAVALANGTHREADFIELDHOLDER_THREADSTATUS(currentThread, threadHolder);`
`2293`	`2292`	`J9VMJAVALANGTHREADFIELDHOLDER_SET_THREADSTATUS(currentThread, threadHolder, state);`
`2294`	`2293`	`}`
`2295`	`2294`	`}`
`2296`	`2295`	`#else /* JAVA_SPEC_VERSION >= 19 */`
`2297`	`2296`	`j9object_t receiverObject = currentThread->threadObject;`
`2298`	`2297`	`if (NULL != receiverObject) {`
`2299`		`- oldState = (U_32)J9VMJAVALANGTHREAD_THREADSTATUS(currentThread, receiverObject);`
	`2298`	`+ oldState = J9VMJAVALANGTHREAD_THREADSTATUS(currentThread, receiverObject);`
`2300`	`2299`	`J9VMJAVALANGTHREAD_SET_THREADSTATUS(currentThread, receiverObject, state);`
`2301`	`2300`	`}`
`2302`	`2301`	`#endif /* JAVA_SPEC_VERSION >= 19 */`