66 import jdk.internal.misc.Blocker;
67 import jdk.internal.misc.CarrierThreadLocal;
68 import jdk.internal.util.StaticProperty;
69 import jdk.internal.module.ModuleBootstrap;
70 import jdk.internal.module.ServicesCatalog;
71 import jdk.internal.reflect.CallerSensitive;
72 import jdk.internal.reflect.Reflection;
73 import jdk.internal.access.JavaLangAccess;
74 import jdk.internal.access.SharedSecrets;
75 import jdk.internal.logger.LoggerFinderLoader;
76 import jdk.internal.logger.LazyLoggers;
77 import jdk.internal.logger.LocalizedLoggerWrapper;
78 import jdk.internal.misc.VM;
79 import jdk.internal.util.SystemProps;
80 import jdk.internal.vm.Continuation;
81 import jdk.internal.vm.ContinuationScope;
82 import jdk.internal.vm.StackableScope;
83 import jdk.internal.vm.ThreadContainer;
84 import jdk.internal.vm.annotation.IntrinsicCandidate;
85 import jdk.internal.vm.annotation.Stable;
86 import sun.reflect.annotation.AnnotationType;
87 import sun.nio.ch.Interruptible;
88 import sun.nio.cs.UTF_8;
89
90 /**
91 * The {@code System} class contains several useful class fields
92 * and methods. It cannot be instantiated.
93 *
94 * Among the facilities provided by the {@code System} class
95 * are standard input, standard output, and error output streams;
96 * access to externally defined properties and environment
97 * variables; a means of loading files and libraries; and a utility
98 * method for quickly copying a portion of an array.
99 *
100 * @since 1.0
101 */
102 public final class System {
103 /* Register the natives via the static initializer.
104 *
105 * The VM will invoke the initPhase1 method to complete the initialization
2252 public <T> void setCarrierThreadLocal(CarrierThreadLocal<T> local, T value) {
2253 ((ThreadLocal<T>)local).setCarrierThreadLocal(value);
2254 }
2255
2256 public void removeCarrierThreadLocal(CarrierThreadLocal<?> local) {
2257 ((ThreadLocal<?>)local).removeCarrierThreadLocal();
2258 }
2259
2260 public Object[] scopedValueCache() {
2261 return Thread.scopedValueCache();
2262 }
2263
2264 public void setScopedValueCache(Object[] cache) {
2265 Thread.setScopedValueCache(cache);
2266 }
2267
2268 public Object scopedValueBindings() {
2269 return Thread.scopedValueBindings();
2270 }
2271
2272 public Continuation getContinuation(Thread thread) {
2273 return thread.getContinuation();
2274 }
2275
2276 public void setContinuation(Thread thread, Continuation continuation) {
2277 thread.setContinuation(continuation);
2278 }
2279
2280 public ContinuationScope virtualThreadContinuationScope() {
2281 return VirtualThread.continuationScope();
2282 }
2283
2284 public void parkVirtualThread() {
2285 Thread thread = Thread.currentThread();
2286 if (thread instanceof BaseVirtualThread vthread) {
2287 vthread.park();
2288 } else {
2289 throw new WrongThreadException();
2290 }
2291 }
2292
2293 public void parkVirtualThread(long nanos) {
2294 Thread thread = Thread.currentThread();
2295 if (thread instanceof BaseVirtualThread vthread) {
2296 vthread.parkNanos(nanos);
2297 } else {
2298 throw new WrongThreadException();
2299 }
2300 }
2301
2302 public void unparkVirtualThread(Thread thread) {
2303 if (thread instanceof BaseVirtualThread vthread) {
2304 vthread.unpark();
2305 } else {
2306 throw new WrongThreadException();
2307 }
2308 }
2309
2310 public Executor virtualThreadDefaultScheduler() {
2311 return VirtualThread.defaultScheduler();
2312 }
2313
2314 public StackWalker newStackWalkerInstance(Set<StackWalker.Option> options,
2315 ContinuationScope contScope,
2316 Continuation continuation) {
2317 return StackWalker.newInstance(options, null, contScope, continuation);
2318 }
2319
2320 public String getLoaderNameID(ClassLoader loader) {
2321 return loader != null ? loader.nameAndId() : "null";
2322 }
2323
2324 @Override
2325 public void copyToSegmentRaw(String string, MemorySegment segment, long offset) {
2326 string.copyToSegmentRaw(segment, offset);
2327 }
2328
2329 @Override
2330 public boolean bytesCompatible(String string, Charset charset) {
2331 return string.bytesCompatible(charset);
2332 }
2333 });
|
66 import jdk.internal.misc.Blocker;
67 import jdk.internal.misc.CarrierThreadLocal;
68 import jdk.internal.util.StaticProperty;
69 import jdk.internal.module.ModuleBootstrap;
70 import jdk.internal.module.ServicesCatalog;
71 import jdk.internal.reflect.CallerSensitive;
72 import jdk.internal.reflect.Reflection;
73 import jdk.internal.access.JavaLangAccess;
74 import jdk.internal.access.SharedSecrets;
75 import jdk.internal.logger.LoggerFinderLoader;
76 import jdk.internal.logger.LazyLoggers;
77 import jdk.internal.logger.LocalizedLoggerWrapper;
78 import jdk.internal.misc.VM;
79 import jdk.internal.util.SystemProps;
80 import jdk.internal.vm.Continuation;
81 import jdk.internal.vm.ContinuationScope;
82 import jdk.internal.vm.StackableScope;
83 import jdk.internal.vm.ThreadContainer;
84 import jdk.internal.vm.annotation.IntrinsicCandidate;
85 import jdk.internal.vm.annotation.Stable;
86 import sun.nio.ch.NativeThread;
87 import sun.reflect.annotation.AnnotationType;
88 import sun.nio.ch.Interruptible;
89 import sun.nio.cs.UTF_8;
90
91 /**
92 * The {@code System} class contains several useful class fields
93 * and methods. It cannot be instantiated.
94 *
95 * Among the facilities provided by the {@code System} class
96 * are standard input, standard output, and error output streams;
97 * access to externally defined properties and environment
98 * variables; a means of loading files and libraries; and a utility
99 * method for quickly copying a portion of an array.
100 *
101 * @since 1.0
102 */
103 public final class System {
104 /* Register the natives via the static initializer.
105 *
106 * The VM will invoke the initPhase1 method to complete the initialization
2253 public <T> void setCarrierThreadLocal(CarrierThreadLocal<T> local, T value) {
2254 ((ThreadLocal<T>)local).setCarrierThreadLocal(value);
2255 }
2256
2257 public void removeCarrierThreadLocal(CarrierThreadLocal<?> local) {
2258 ((ThreadLocal<?>)local).removeCarrierThreadLocal();
2259 }
2260
2261 public Object[] scopedValueCache() {
2262 return Thread.scopedValueCache();
2263 }
2264
2265 public void setScopedValueCache(Object[] cache) {
2266 Thread.setScopedValueCache(cache);
2267 }
2268
2269 public Object scopedValueBindings() {
2270 return Thread.scopedValueBindings();
2271 }
2272
2273 public NativeThread nativeThread(Thread thread) {
2274 return thread.nativeThread();
2275 }
2276
2277 public void setNativeThread(NativeThread nt) {
2278 Thread.currentThread().setNativeThread(nt);
2279 }
2280
2281 public Continuation getContinuation(Thread thread) {
2282 return thread.getContinuation();
2283 }
2284
2285 public void setContinuation(Thread thread, Continuation continuation) {
2286 thread.setContinuation(continuation);
2287 }
2288
2289 public ContinuationScope virtualThreadContinuationScope() {
2290 return VirtualThread.continuationScope();
2291 }
2292
2293 public void parkVirtualThread() {
2294 Thread thread = Thread.currentThread();
2295 if (thread instanceof BaseVirtualThread vthread) {
2296 vthread.park();
2297 } else {
2298 throw new WrongThreadException();
2299 }
2300 }
2301
2302 public void parkVirtualThread(long nanos) {
2303 Thread thread = Thread.currentThread();
2304 if (thread instanceof BaseVirtualThread vthread) {
2305 vthread.parkNanos(nanos);
2306 } else {
2307 throw new WrongThreadException();
2308 }
2309 }
2310
2311 public void unparkVirtualThread(Thread thread) {
2312 if (thread instanceof BaseVirtualThread vthread) {
2313 vthread.unpark();
2314 } else {
2315 throw new IllegalArgumentException();
2316 }
2317 }
2318
2319 public Thread.VirtualThreadScheduler defaultVirtualThreadScheduler() {
2320 return VirtualThread.defaultScheduler();
2321 }
2322
2323 public boolean isCustomDefaultVirtualThreadScheduler() {
2324 return VirtualThread.isCustomDefaultScheduler();
2325 }
2326
2327 public Thread.VirtualThreadScheduler virtualThreadScheduler(Thread thread) {
2328 if (thread instanceof VirtualThread vthread) {
2329 return vthread.scheduler(true);
2330 } else {
2331 throw new IllegalArgumentException();
2332 }
2333 }
2334
2335 public <T> T supplyIfUnmounted(Thread thread, Supplier<T> supplier1, Supplier<T> supplier2) {
2336 if (thread instanceof VirtualThread vthread) {
2337 return vthread.supplyIfUnmounted(supplier1, supplier2);
2338 } else {
2339 throw new IllegalArgumentException();
2340 }
2341 }
2342
2343 public StackWalker newStackWalkerInstance(Set<StackWalker.Option> options,
2344 ContinuationScope contScope,
2345 Continuation continuation) {
2346 return StackWalker.newInstance(options, null, contScope, continuation);
2347 }
2348
2349 public String getLoaderNameID(ClassLoader loader) {
2350 return loader != null ? loader.nameAndId() : "null";
2351 }
2352
2353 @Override
2354 public void copyToSegmentRaw(String string, MemorySegment segment, long offset) {
2355 string.copyToSegmentRaw(segment, offset);
2356 }
2357
2358 @Override
2359 public boolean bytesCompatible(String string, Charset charset) {
2360 return string.bytesCompatible(charset);
2361 }
2362 });
|