Rename VirtualThreads.get() to .singleton() for consistency.

peter-hofer · peter-hofer · commit 25d879802084 · 2022-01-31T19:46:40.000+01:00
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/Target_java_lang_StackWalker.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/Target_java_lang_StackWalker.java
@@ -146,7 +146,7 @@ private <T> T walk(Function<? super Stream<StackFrame>, ? extends T> function) {
             JavaStackWalk walk = StackValue.get(JavaStackWalk.class);
             Pointer sp = KnownIntrinsics.readCallerStackPointer();
 
-            if (LoomSupport.isEnabled() && (this.contScope != null || VirtualThreads.get().isVirtual(thread))) {
+            if (LoomSupport.isEnabled() && (this.contScope != null || VirtualThreads.singleton().isVirtual(thread))) {
                 // has a delimitation scope
                 Target_java_lang_ContinuationScope delimitationScope = this.contScope != null ? this.contScope : Target_java_lang_VirtualThread.continuationScope();
                 Target_java_lang_Continuation topContinuation = Target_java_lang_Continuation.getCurrentContinuation(delimitationScope);
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/ContinuationSubstitutions.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/ContinuationSubstitutions.java
@@ -45,8 +45,8 @@ final class Target_java_util_concurrent_locks_LockSupport {
     @Substitute
     static void unpark(Thread thread) {
         if (thread != null) {
-            if (VirtualThreads.get().isVirtual(thread)) {
-                VirtualThreads.get().unpark(thread);
+            if (VirtualThreads.singleton().isVirtual(thread)) {
+                VirtualThreads.singleton().unpark(thread);
             } else {
                 U.unpark(thread);
             }
@@ -58,8 +58,8 @@ static void park(Object blocker) {
         Thread t = Thread.currentThread();
         setBlocker(t, blocker);
         try {
-            if (VirtualThreads.get().isVirtual(t)) {
-                VirtualThreads.get().park();
+            if (VirtualThreads.singleton().isVirtual(t)) {
+                VirtualThreads.singleton().park();
             } else {
                 U.park(false, 0L);
             }
@@ -74,8 +74,8 @@ static void parkNanos(Object blocker, long nanos) {
             Thread t = Thread.currentThread();
             setBlocker(t, blocker);
             try {
-                if (VirtualThreads.get().isVirtual(t)) {
-                    VirtualThreads.get().parkNanos(nanos);
+                if (VirtualThreads.singleton().isVirtual(t)) {
+                    VirtualThreads.singleton().parkNanos(nanos);
                 } else {
                     U.park(false, nanos);
                 }
@@ -90,8 +90,8 @@ static void parkUntil(Object blocker, long deadline) {
         Thread t = Thread.currentThread();
         setBlocker(t, blocker);
         try {
-            if (VirtualThreads.get().isVirtual(t)) {
-                VirtualThreads.get().parkUntil(deadline);
+            if (VirtualThreads.singleton().isVirtual(t)) {
+                VirtualThreads.singleton().parkUntil(deadline);
             } else {
                 U.park(true, deadline);
             }
@@ -102,8 +102,8 @@ static void parkUntil(Object blocker, long deadline) {
 
     @Substitute
     static void park() {
-        if (VirtualThreads.get().isVirtual(Thread.currentThread())) {
-            VirtualThreads.get().park();
+        if (VirtualThreads.singleton().isVirtual(Thread.currentThread())) {
+            VirtualThreads.singleton().park();
         } else {
             U.park(false, 0L);
         }
@@ -112,8 +112,8 @@ static void park() {
     @Substitute
     public static void parkNanos(long nanos) {
         if (nanos > 0) {
-            if (VirtualThreads.get().isVirtual(Thread.currentThread())) {
-                VirtualThreads.get().parkNanos(nanos);
+            if (VirtualThreads.singleton().isVirtual(Thread.currentThread())) {
+                VirtualThreads.singleton().parkNanos(nanos);
                 ((SubstrateVirtualThread) Thread.currentThread()).parkNanos(nanos);
             } else {
                 U.park(false, nanos);
@@ -123,8 +123,8 @@ public static void parkNanos(long nanos) {
 
     @Substitute
     public static void parkUntil(long deadline) {
-        if (VirtualThreads.get().isVirtual(Thread.currentThread())) {
-            VirtualThreads.get().parkUntil(deadline);
+        if (VirtualThreads.singleton().isVirtual(Thread.currentThread())) {
+            VirtualThreads.singleton().parkUntil(deadline);
         } else {
             U.park(true, deadline);
         }
@@ -147,12 +147,12 @@ static int get(Target_sun_nio_ch_NativeThreadSet that) {
 
     static void set(Target_sun_nio_ch_NativeThreadSet that, int value) {
         // Note that the accessing method holds a lock that prevents concurrent updates
-        if (VirtualThreads.get().isVirtual(Thread.currentThread())) {
+        if (VirtualThreads.singleton().isVirtual(Thread.currentThread())) {
             int diff = value - that.injectedUsed;
             if (diff == 1) {
-                VirtualThreads.get().pinCurrent();
+                VirtualThreads.singleton().pinCurrent();
             } else if (diff == -1) {
-                VirtualThreads.get().unpinCurrent();
+                VirtualThreads.singleton().unpinCurrent();
             } else {
                 assert value == 0 : "must only be incremented or decremented by 1 (or initialized to 0)";
             }
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/Continuations.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/Continuations.java
@@ -28,7 +28,7 @@
 
 public final class Continuations {
     public static ThreadFactory virtualThreadFactory() {
-        return VirtualThreads.get().createFactory();
+        return VirtualThreads.singleton().createFactory();
     }
 
     private Continuations() {
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/JavaThreads.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/JavaThreads.java
@@ -123,7 +123,7 @@ private static boolean getInterruptedFlag(Thread thread) {
 
     static boolean getAndClearInterrupt(Thread thread) {
         if (supportsVirtual() && isVirtual(thread)) {
-            return VirtualThreads.get().getAndClearInterrupt(thread);
+            return VirtualThreads.singleton().getAndClearInterrupt(thread);
         }
         return getAndClearInterruptedFlag(thread);
     }
@@ -162,7 +162,7 @@ static boolean supportsVirtual() {
     }
 
     static boolean isVirtual(Thread thread) {
-        return supportsVirtual() && VirtualThreads.get().isVirtual(thread);
+        return supportsVirtual() && VirtualThreads.singleton().isVirtual(thread);
     }
 
     private static boolean isVirtualDisallowLoom(Thread thread) {
@@ -183,15 +183,15 @@ static void join(Thread thread, long millis) throws InterruptedException {
             throw new IllegalArgumentException("timeout value is negative");
         }
         if (supportsVirtual() && isVirtual(thread)) {
-            VirtualThreads.get().join(thread, millis);
+            VirtualThreads.singleton().join(thread, millis);
         } else {
             PlatformThreads.join(thread, millis);
         }
     }
 
     static void yieldCurrent() {
         if (supportsVirtual() && isVirtualDisallowLoom(Thread.currentThread())) {
-            VirtualThreads.get().yield();
+            VirtualThreads.singleton().yield();
         } else {
             PlatformThreads.singleton().yieldCurrent();
         }
@@ -281,7 +281,7 @@ static void initializeNewThread(
         }
         LoomSupport.CompatibilityUtil.initThreadFields(tjlt, group, target, stackSize, priority, daemon, ThreadStatus.NEW);
 
-        if (!LoomSupport.isEnabled() && !(VirtualThreads.isSupported() && VirtualThreads.get().isVirtual(fromTarget(tjlt)))) {
+        if (!LoomSupport.isEnabled() && !(VirtualThreads.isSupported() && VirtualThreads.singleton().isVirtual(fromTarget(tjlt)))) {
             JavaThreads.toTarget(group).addUnstarted();
         }
 
@@ -295,15 +295,15 @@ static void initializeNewThread(
 
     static void sleep(long millis) throws InterruptedException {
         if (supportsVirtual() && isVirtualDisallowLoom(Thread.currentThread())) {
-            VirtualThreads.get().sleepMillis(millis);
+            VirtualThreads.singleton().sleepMillis(millis);
         } else {
             PlatformThreads.sleep(millis);
         }
     }
 
     static boolean isAlive(Thread thread) {
         if (supportsVirtual() && isVirtualDisallowLoom(thread)) {
-            return VirtualThreads.get().isAlive(thread);
+            return VirtualThreads.singleton().isAlive(thread);
         }
         return PlatformThreads.isAlive(thread);
     }
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/Target_java_lang_Thread.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/Target_java_lang_Thread.java
@@ -518,7 +518,7 @@ private static boolean holdsLock(Object obj) {
 
     @Substitute
     private StackTraceElement[] getStackTrace() {
-        if (LoomSupport.isEnabled() && VirtualThreads.get().isVirtual(JavaThreads.fromTarget(this))) {
+        if (LoomSupport.isEnabled() && VirtualThreads.singleton().isVirtual(JavaThreads.fromTarget(this))) {
             return asyncGetStackTrace();
         }
         return JavaThreads.getStackTrace(JavaThreads.fromTarget(this));
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/Target_jdk_internal_misc_Unsafe_JavaThreads.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/Target_jdk_internal_misc_Unsafe_JavaThreads.java
@@ -74,7 +74,7 @@ void unpark(Object threadObj) {
                 throw new IllegalArgumentException("Unsafe.unpark(!(thread instanceof Thread))");
             }
             Thread thread = (Thread) threadObj;
-            if (!VirtualThreads.isSupported() || !VirtualThreads.get().isVirtual(thread)) {
+            if (!VirtualThreads.isSupported() || !VirtualThreads.singleton().isVirtual(thread)) {
                 PlatformThreads.unpark(thread);
             }
         }
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/VirtualThreads.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/VirtualThreads.java
@@ -32,7 +32,7 @@
 /** Operations on virtual threads. */
 public interface VirtualThreads {
     @Fold
-    static VirtualThreads get() {
+    static VirtualThreads singleton() {
         ContinuationsFeature.abortIfUnsupported();
         return ImageSingletons.lookup(VirtualThreads.class);
     }
diff --git a/substratevm/src/com.oracle.svm.jni/src/com/oracle/svm/jni/functions/JNIFunctions.java b/substratevm/src/com.oracle.svm.jni/src/com/oracle/svm/jni/functions/JNIFunctions.java
@@ -1017,11 +1017,11 @@ static int MonitorEnter(JNIEnvironment env, JNIObjectHandle handle) {
             throw new NullPointerException();
         }
         boolean pinned = false;
-        if (VirtualThreads.isSupported() && VirtualThreads.get().isVirtual(Thread.currentThread())) {
+        if (VirtualThreads.isSupported() && VirtualThreads.singleton().isVirtual(Thread.currentThread())) {
             // Acquiring monitors via JNI associates them with the carrier thread via
             // JNIThreadOwnedMonitors, so we must pin the virtual thread
             try {
-                VirtualThreads.get().pinCurrent();
+                VirtualThreads.singleton().pinCurrent();
             } catch (IllegalStateException e) { // too many pins
                 throw new IllegalMonitorStateException();
             }
@@ -1041,7 +1041,7 @@ static int MonitorEnter(JNIEnvironment env, JNIObjectHandle handle) {
                     MonitorSupport.singleton().monitorExit(obj);
                 }
                 if (pinned) {
-                    VirtualThreads.get().unpinCurrent();
+                    VirtualThreads.singleton().unpinCurrent();
                 }
             } catch (Throwable u) {
                 throw VMError.shouldNotReachHere(u);
@@ -1065,9 +1065,9 @@ static int MonitorExit(JNIEnvironment env, JNIObjectHandle handle) {
         }
         MonitorSupport.singleton().monitorExit(obj);
         JNIThreadOwnedMonitors.exited(obj);
-        if (VirtualThreads.isSupported() && VirtualThreads.get().isVirtual(Thread.currentThread())) {
+        if (VirtualThreads.isSupported() && VirtualThreads.singleton().isVirtual(Thread.currentThread())) {
             try {
-                VirtualThreads.get().unpinCurrent();
+                VirtualThreads.singleton().unpinCurrent();
             } catch (IllegalStateException e) { // not pinned?
                 throw new IllegalMonitorStateException();
             }

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@`
`28`	`28`
`29`	`29`	`public final class Continuations {`
`30`	`30`	`public static ThreadFactory virtualThreadFactory() {`
`31`		`- return VirtualThreads.get().createFactory();`
	`31`	`+ return VirtualThreads.singleton().createFactory();`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`private Continuations() {`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ private static boolean getInterruptedFlag(Thread thread) {`
`123`	`123`
`124`	`124`	`static boolean getAndClearInterrupt(Thread thread) {`
`125`	`125`	`if (supportsVirtual() && isVirtual(thread)) {`
`126`		`- return VirtualThreads.get().getAndClearInterrupt(thread);`
	`126`	`+ return VirtualThreads.singleton().getAndClearInterrupt(thread);`
`127`	`127`	`}`
`128`	`128`	`return getAndClearInterruptedFlag(thread);`
`129`	`129`	`}`
`@@ -162,7 +162,7 @@ static boolean supportsVirtual() {`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`static boolean isVirtual(Thread thread) {`
`165`		`- return supportsVirtual() && VirtualThreads.get().isVirtual(thread);`
	`165`	`+ return supportsVirtual() && VirtualThreads.singleton().isVirtual(thread);`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`private static boolean isVirtualDisallowLoom(Thread thread) {`
`@@ -183,15 +183,15 @@ static void join(Thread thread, long millis) throws InterruptedException {`
`183`	`183`	`throw new IllegalArgumentException("timeout value is negative");`
`184`	`184`	`}`
`185`	`185`	`if (supportsVirtual() && isVirtual(thread)) {`
`186`		`- VirtualThreads.get().join(thread, millis);`
	`186`	`+ VirtualThreads.singleton().join(thread, millis);`
`187`	`187`	`} else {`
`188`	`188`	`PlatformThreads.join(thread, millis);`
`189`	`189`	`}`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`static void yieldCurrent() {`
`193`	`193`	`if (supportsVirtual() && isVirtualDisallowLoom(Thread.currentThread())) {`
`194`		`- VirtualThreads.get().yield();`
	`194`	`+ VirtualThreads.singleton().yield();`
`195`	`195`	`} else {`
`196`	`196`	`PlatformThreads.singleton().yieldCurrent();`
`197`	`197`	`}`
`@@ -281,7 +281,7 @@ static void initializeNewThread(`
`281`	`281`	`}`
`282`	`282`	`LoomSupport.CompatibilityUtil.initThreadFields(tjlt, group, target, stackSize, priority, daemon, ThreadStatus.NEW);`
`283`	`283`
`284`		`- if (!LoomSupport.isEnabled() && !(VirtualThreads.isSupported() && VirtualThreads.get().isVirtual(fromTarget(tjlt)))) {`
	`284`	`+ if (!LoomSupport.isEnabled() && !(VirtualThreads.isSupported() && VirtualThreads.singleton().isVirtual(fromTarget(tjlt)))) {`
`285`	`285`	`JavaThreads.toTarget(group).addUnstarted();`
`286`	`286`	`}`
`287`	`287`
`@@ -295,15 +295,15 @@ static void initializeNewThread(`
`295`	`295`
`296`	`296`	`static void sleep(long millis) throws InterruptedException {`
`297`	`297`	`if (supportsVirtual() && isVirtualDisallowLoom(Thread.currentThread())) {`
`298`		`- VirtualThreads.get().sleepMillis(millis);`
	`298`	`+ VirtualThreads.singleton().sleepMillis(millis);`
`299`	`299`	`} else {`
`300`	`300`	`PlatformThreads.sleep(millis);`
`301`	`301`	`}`
`302`	`302`	`}`
`303`	`303`
`304`	`304`	`static boolean isAlive(Thread thread) {`
`305`	`305`	`if (supportsVirtual() && isVirtualDisallowLoom(thread)) {`
`306`		`- return VirtualThreads.get().isAlive(thread);`
	`306`	`+ return VirtualThreads.singleton().isAlive(thread);`
`307`	`307`	`}`
`308`	`308`	`return PlatformThreads.isAlive(thread);`
`309`	`309`	`}`
Original file line number	Diff line number	Diff line change
`@@ -518,7 +518,7 @@ private static boolean holdsLock(Object obj) {`
`518`	`518`
`519`	`519`	`@Substitute`
`520`	`520`	`private StackTraceElement[] getStackTrace() {`
`521`		`- if (LoomSupport.isEnabled() && VirtualThreads.get().isVirtual(JavaThreads.fromTarget(this))) {`
	`521`	`+ if (LoomSupport.isEnabled() && VirtualThreads.singleton().isVirtual(JavaThreads.fromTarget(this))) {`
`522`	`522`	`return asyncGetStackTrace();`
`523`	`523`	`}`
`524`	`524`	`return JavaThreads.getStackTrace(JavaThreads.fromTarget(this));`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ void unpark(Object threadObj) {`
`74`	`74`	`throw new IllegalArgumentException("Unsafe.unpark(!(thread instanceof Thread))");`
`75`	`75`	`}`
`76`	`76`	`Thread thread = (Thread) threadObj;`
`77`		`- if (!VirtualThreads.isSupported() \|\| !VirtualThreads.get().isVirtual(thread)) {`
	`77`	`+ if (!VirtualThreads.isSupported() \|\| !VirtualThreads.singleton().isVirtual(thread)) {`
`78`	`78`	`PlatformThreads.unpark(thread);`
`79`	`79`	`}`
`80`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@`
`32`	`32`	`/** Operations on virtual threads. */`
`33`	`33`	`public interface VirtualThreads {`
`34`	`34`	`@Fold`
`35`		`- static VirtualThreads get() {`
	`35`	`+ static VirtualThreads singleton() {`
`36`	`36`	`ContinuationsFeature.abortIfUnsupported();`
`37`	`37`	`return ImageSingletons.lookup(VirtualThreads.class);`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1017,11 +1017,11 @@ static int MonitorEnter(JNIEnvironment env, JNIObjectHandle handle) {`
`1017`	`1017`	`throw new NullPointerException();`
`1018`	`1018`	`}`
`1019`	`1019`	`boolean pinned = false;`
`1020`		`- if (VirtualThreads.isSupported() && VirtualThreads.get().isVirtual(Thread.currentThread())) {`
	`1020`	`+ if (VirtualThreads.isSupported() && VirtualThreads.singleton().isVirtual(Thread.currentThread())) {`
`1021`	`1021`	`// Acquiring monitors via JNI associates them with the carrier thread via`
`1022`	`1022`	`// JNIThreadOwnedMonitors, so we must pin the virtual thread`
`1023`	`1023`	`try {`
`1024`		`- VirtualThreads.get().pinCurrent();`
	`1024`	`+ VirtualThreads.singleton().pinCurrent();`
`1025`	`1025`	`} catch (IllegalStateException e) { // too many pins`
`1026`	`1026`	`throw new IllegalMonitorStateException();`
`1027`	`1027`	`}`
`@@ -1041,7 +1041,7 @@ static int MonitorEnter(JNIEnvironment env, JNIObjectHandle handle) {`
`1041`	`1041`	`MonitorSupport.singleton().monitorExit(obj);`
`1042`	`1042`	`}`
`1043`	`1043`	`if (pinned) {`
`1044`		`- VirtualThreads.get().unpinCurrent();`
	`1044`	`+ VirtualThreads.singleton().unpinCurrent();`
`1045`	`1045`	`}`
`1046`	`1046`	`} catch (Throwable u) {`
`1047`	`1047`	`throw VMError.shouldNotReachHere(u);`
`@@ -1065,9 +1065,9 @@ static int MonitorExit(JNIEnvironment env, JNIObjectHandle handle) {`
`1065`	`1065`	`}`
`1066`	`1066`	`MonitorSupport.singleton().monitorExit(obj);`
`1067`	`1067`	`JNIThreadOwnedMonitors.exited(obj);`
`1068`		`- if (VirtualThreads.isSupported() && VirtualThreads.get().isVirtual(Thread.currentThread())) {`
	`1068`	`+ if (VirtualThreads.isSupported() && VirtualThreads.singleton().isVirtual(Thread.currentThread())) {`
`1069`	`1069`	`try {`
`1070`		`- VirtualThreads.get().unpinCurrent();`
	`1070`	`+ VirtualThreads.singleton().unpinCurrent();`
`1071`	`1071`	`} catch (IllegalStateException e) { // not pinned?`
`1072`	`1072`	`throw new IllegalMonitorStateException();`
`1073`	`1073`	`}`