Avoid virtual-thread yield spin in ConcurrentBag (#2402)

Excellent! Thanks for the deep-dive and pull request.

Author: ittaigolde

src/main/java/com/zaxxer/hikari/util/ConcurrentBag.java

@@ -19,6 +19,9 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -61,6 +64,7 @@
 public class ConcurrentBag<T extends IConcurrentBagEntry> implements AutoCloseable
 {
    private static final Logger LOGGER = LoggerFactory.getLogger(ConcurrentBag.class);
+   private static final MethodHandle THREAD_IS_VIRTUAL = resolveThreadIsVirtual();
 
    private final CopyOnWriteArrayList<T> sharedList;
    private final boolean useWeakThreadLocals;
@@ -72,6 +76,31 @@ public class ConcurrentBag<T extends IConcurrentBagEntry> implements AutoCloseab
 
    private final SynchronousQueue<T> handoffQueue;
 
+   private static MethodHandle resolveThreadIsVirtual()
+   {
+      try {
+         return MethodHandles.publicLookup()
+            .findVirtual(Thread.class, "isVirtual", MethodType.methodType(boolean.class));
+      }
+      catch (NoSuchMethodException | IllegalAccessException e) {
+         return null;
+      }
+   }
+
+   static boolean isCurrentThreadVirtual()
+   {
+      if (THREAD_IS_VIRTUAL == null) {
+         return false;
+      }
+
+      try {
+         return (boolean) THREAD_IS_VIRTUAL.invokeExact(Thread.currentThread());
+      }
+      catch (Throwable t) {
+         return false;
+      }
+   }
+
    /**
     * This interface defines the contract for an entry in the ConcurrentBag.
     * It provides methods to manage the state of the entry, which can be
@@ -188,11 +217,12 @@ public void requite(final T bagEntry)
    {
       bagEntry.setState(STATE_NOT_IN_USE);
 
+      final var isVirtualThread = isCurrentThreadVirtual();
       for (int i = 1, waiting = waiters.get(); waiting > 0; i++, waiting = waiters.get()) {
          if (bagEntry.getState() != STATE_NOT_IN_USE || handoffQueue.offer(bagEntry)) {
             return;
          }
-         else if ((i & 0xff) == 0xff || (waiting > 1 && i % waiting == 0)) {
+         else if (isVirtualThread || (i & 0xff) == 0xff || (waiting > 1 && i % waiting == 0)) {
             parkNanos(MICROSECONDS.toNanos(10));
          }
          else {
@@ -319,11 +349,12 @@ public void unreserve(final T bagEntry)
    {
       if (bagEntry.compareAndSet(STATE_RESERVED, STATE_NOT_IN_USE)) {
          // spin until a thread takes it or none are waiting
+         final var isVirtualThread = isCurrentThreadVirtual();
          for (int i = 1, waiting = waiters.get(); waiting > 0; i++, waiting = waiters.get()) {
             if (bagEntry.getState() != STATE_NOT_IN_USE || handoffQueue.offer(bagEntry)) {
                return;
             }
-            else if ((i & 0xff) == 0xff || (waiting > 1 && i % waiting == 0)) {
+            else if (isVirtualThread || (i & 0xff) == 0xff || (waiting > 1 && i % waiting == 0)) {
                parkNanos(MICROSECONDS.toNanos(10));
             }
             else {

src/test/java/com/zaxxer/hikari/util/ConcurrentBagVirtualThreadTest.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2026 Brett Wooldridge
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.zaxxer.hikari.util;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import java.lang.reflect.Method;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.junit.Test;
+
+public class ConcurrentBagVirtualThreadTest
+{
+   @Test
+   public void detectsCurrentVirtualThread() throws Exception
+   {
+      assertFalse(ConcurrentBag.isCurrentThreadVirtual());
+
+      final var ofVirtual = virtualThreadBuilderFactory();
+      assumeTrue(ofVirtual != null);
+
+      final var virtualThreadBuilder = ofVirtual.invoke(null);
+      final var start = Class.forName("java.lang.Thread$Builder$OfVirtual").getMethod("start", Runnable.class);
+      final var detected = new AtomicBoolean();
+
+      final var virtualThread = (Thread) start.invoke(virtualThreadBuilder,
+         (Runnable) () -> detected.set(ConcurrentBag.isCurrentThreadVirtual()));
+      virtualThread.join();
+
+      assertTrue(detected.get());
+   }
+
+   private static Method virtualThreadBuilderFactory()
+   {
+      try {
+         return Thread.class.getMethod("ofVirtual");
+      }
+      catch (NoSuchMethodException e) {
+         return null;
+      }
+   }
+}