Name change

Author: franz1981

core/src/main/java/io/netty/loom/EventLoopScheduler.java

@@ -12,11 +12,11 @@
 
 public class EventLoopScheduler {
 
-    public static final class SchedulerRef {
+    public static final class SharedRef {
 
         private volatile EventLoopScheduler ref;
 
-        private SchedulerRef(EventLoopScheduler ref) {
+        private SharedRef(EventLoopScheduler ref) {
             this.ref = ref;
         }
 
@@ -31,13 +31,13 @@ public EventLoopScheduler get() {
      * This means that if they try to unpark some virtual thread which belong to this scheduler,
      * they can still wakeup the carrier thread. It's more a performance defect, but won't affect correctness.
      */
-    public record SchedulerContext(long vThreadId, SchedulerRef scheduler) {
+    public record SchedulingContext(long vThreadId, SharedRef scheduler) {
 
         /**
          * Get the assigned scheduler for the current thread, or null if this thread is not assigned to any scheduler.
          */
         @Override
-        public SchedulerRef scheduler() {
+        public SharedRef scheduler() {
             // TODO consider returning EMPTY_SCHEDULER_REF instead of null
             return (Thread.currentThread().threadId() == vThreadId) ? scheduler : null;
         }
@@ -50,8 +50,8 @@ public SchedulerRef scheduler() {
    private static final long RUNNING_YIELD_US = TimeUnit.MICROSECONDS.toNanos(Integer.getInteger("io.netty.loom.running.yield.us", 1));
    private static final long IDLE_YIELD_US = TimeUnit.MICROSECONDS.toNanos(Integer.getInteger("io.netty.loom.idle.yield.us", 1));
    // This is required to allow sub-pollers to run on the correct scheduler
-   private static final ScopedValue<SchedulerContext> CURRENT_SCHEDULER = ScopedValue.newInstance();
-   private static final SchedulerContext EMPTY_SCHEDULER_CONTEXT = new SchedulerContext(-1, null);
+   private static final ScopedValue<SchedulingContext> CURRENT_SCHEDULER = ScopedValue.newInstance();
+   private static final SchedulingContext EMPTY_SCHEDULER_CONTEXT = new SchedulingContext(-1, null);
    private final MpscUnboundedStream<Runnable> runQueue;
    private final ManualIoEventLoop ioEventLoop;
    private final Thread eventLoopThread;
@@ -60,10 +60,10 @@ public SchedulerRef scheduler() {
    private volatile Runnable eventLoopContinuatioToRun;
    private final ThreadFactory vThreadFactory;
    private final AtomicBoolean eventLoopIsRunning;
-   private final SchedulerRef sharedRef;
+   private final SharedRef sharedRef;
 
    public EventLoopScheduler(IoEventLoopGroup parent, ThreadFactory threadFactory, IoHandlerFactory ioHandlerFactory, int resumedContinuationsExpectedCount) {
-      sharedRef = new SchedulerRef(this);
+      sharedRef = new SharedRef(this);
       eventLoopIsRunning = new AtomicBoolean(false);
       runQueue = new MpscUnboundedStream<>(resumedContinuationsExpectedCount);
       carrierThread = threadFactory.newThread(this::virtualThreadSchedulerLoop);
@@ -72,7 +72,7 @@ public EventLoopScheduler(IoEventLoopGroup parent, ThreadFactory threadFactory,
               NettyScheduler.assignUnstarted(rawVTFactory.newThread(
                       () ->   // this can be inherited by any thread created in the context of this virtual thread
                               // but only the original virtual thread will have the correct scheduler context
-                              ScopedValue.where(CURRENT_SCHEDULER, new SchedulerContext(Thread.currentThread().threadId(), sharedRef)).run(runnable)
+                              ScopedValue.where(CURRENT_SCHEDULER, new SchedulingContext(Thread.currentThread().threadId(), sharedRef)).run(runnable)
               ), sharedRef);
       eventLoopThread = vThreadFactory.newThread(() -> FastThreadLocalThread.runWithFastThreadLocal(this::nettyEventLoop));
       ioEventLoop = new ManualIoEventLoop(parent, eventLoopThread,
@@ -240,7 +240,7 @@ public boolean execute(Thread.VirtualThreadTask task) {
       return true;
    }
 
-   public static SchedulerContext currentThreadSchedulerContext() {
+   public static SchedulingContext currentThreadSchedulerContext() {
       return CURRENT_SCHEDULER.orElse(EMPTY_SCHEDULER_CONTEXT);
    }
 }

core/src/main/java/io/netty/loom/NettyScheduler.java

@@ -1,6 +1,6 @@
 package io.netty.loom;
 
-import io.netty.loom.EventLoopScheduler.SchedulerRef;
+import io.netty.loom.EventLoopScheduler.SharedRef;
 
 import java.lang.invoke.VarHandle;
 import java.util.concurrent.ConcurrentHashMap;
@@ -25,7 +25,7 @@ public class NettyScheduler implements Thread.VirtualThreadScheduler {
 
     private final Thread.VirtualThreadScheduler jdkBuildinScheduler;
 
-    private final ConcurrentHashMap<Thread, SchedulerRef> unstartedThreads = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Thread, SharedRef> unstartedThreads = new ConcurrentHashMap<>();
 
     public NettyScheduler(Thread.VirtualThreadScheduler jdkBuildinScheduler) {
         this.jdkBuildinScheduler = jdkBuildinScheduler;
@@ -85,7 +85,7 @@ public void onStart(Thread.VirtualThreadTask virtualThreadTask) {
     @Override
     public void onContinue(Thread.VirtualThreadTask virtualThreadTask) {
         var attachment = virtualThreadTask.attachment();
-        if (attachment instanceof SchedulerRef ref) {
+        if (attachment instanceof SharedRef ref) {
             var assignedScheduler = ref.get();
             if (assignedScheduler != null) {
                 if (assignedScheduler.execute(virtualThreadTask)) {
@@ -98,7 +98,7 @@ public void onContinue(Thread.VirtualThreadTask virtualThreadTask) {
         jdkBuildinScheduler.onContinue(virtualThreadTask);
     }
 
-    static Thread assignUnstarted(Thread unstarted, SchedulerRef ref) {
+    static Thread assignUnstarted(Thread unstarted, SharedRef ref) {
         INSTANCE.unstartedThreads.put(unstarted, ref);
         return unstarted;
     }

core/src/test/java/io/netty/loom/VirtualMultithreadIoEventLoopGroupTest.java

@@ -353,7 +353,7 @@ void schedulerIsInheritedByForkedVTFromTheRightFactory() throws InterruptedExcep
     void schedulerIsNotInheritedByForkedVT() throws InterruptedException, ExecutionException {
         try (var group = new VirtualMultithreadIoEventLoopGroup(1, LocalIoHandler.newFactory())) {
             final var vThreadFactory = group.submit(group::vThreadFactory).get();
-            var schedulerRef = new CompletableFuture<EventLoopScheduler.SchedulerRef>();
+            var schedulerRef = new CompletableFuture<EventLoopScheduler.SharedRef>();
             vThreadFactory.newThread(() -> {
                 try (var scope = StructuredTaskScope.open(allSuccessfulOrThrow())) {
                     var task = scope.fork(() -> EventLoopScheduler.currentThreadSchedulerContext().scheduler());