diff a/src/java.base/share/classes/jdk/internal/misc/Blocker.java b/src/java.base/share/classes/jdk/internal/misc/Blocker.java
--- a/src/java.base/share/classes/jdk/internal/misc/Blocker.java
+++ b/src/java.base/share/classes/jdk/internal/misc/Blocker.java
@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2019, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
@@ -23,24 +23,22 @@
  * questions.
  */
 
 package jdk.internal.misc;
 
-import java.util.concurrent.ForkJoinPool;
 import jdk.internal.access.JavaLangAccess;
-import jdk.internal.access.JavaUtilConcurrentFJPAccess;
 import jdk.internal.access.SharedSecrets;
 
 /**
  * Defines static methods to mark the beginning and end of a possibly blocking
  * operation. The methods are intended to be used with try-finally as follows:
  * {@snippet lang=java :
- *     long comp = Blocker.begin();
+ *     boolean attempted = Blocker.begin();
  *     try {
  *         // blocking operation
  *     } finally {
- *         Blocker.end(comp);
+ *         Blocker.end(attempted);
  *     }
  * }
  * If invoked from a virtual thread and the underlying carrier thread is a
  * CarrierThread then the code in the block runs as if it were in run in
  * ForkJoinPool.ManagedBlocker. This means the pool can be expanded to support
@@ -60,66 +58,37 @@
     private static Thread currentCarrierThread() {
         return JLA.currentCarrierThread();
     }
 
     /**
-     * Marks the beginning of a possibly blocking operation.
-     * @return the return value from the attempt to compensate or -1 if not attempted
+     * Marks the beginning of a blocking operation.
+     * @return true if tryCompensate attempted
      */
-    public static long begin() {
+    public static boolean begin() {
         if (VM.isBooted()
-                && currentCarrierThread() instanceof CarrierThread ct && !ct.inBlocking()) {
-            ct.beginBlocking();
-            boolean completed = false;
-            try {
-                long comp = ForkJoinPools.beginCompensatedBlock(ct.getPool());
-                assert currentCarrierThread() == ct;
-                completed = true;
-                return comp;
-            } finally {
-                if (!completed) {
-                    ct.endBlocking();
-                }
-            }
+                && Thread.currentThread().isVirtual()
+                && currentCarrierThread() instanceof CarrierThread ct) {
+            return ct.beginBlocking();
         }
-        return -1;
+        return false;
     }
 
     /**
      * Marks the beginning of a possibly blocking operation.
      * @param blocking true if the operation may block, otherwise false
-     * @return the return value from the attempt to compensate, -1 if not attempted
-     * or blocking is false
+     * @return true if tryCompensate attempted
      */
-    public static long begin(boolean blocking) {
-        return (blocking) ? begin() : -1;
+    public static boolean begin(boolean blocking) {
+        return (blocking) ? begin() : false;
     }
 
     /**
      * Marks the end of an operation that may have blocked.
-     * @param compensateReturn the value returned by the begin method
+     * @param attempted if tryCompensate attempted
      */
-    public static void end(long compensateReturn) {
-        if (compensateReturn >= 0) {
-            assert currentCarrierThread() instanceof CarrierThread ct && ct.inBlocking();
+    public static void end(boolean attempted) {
+        if (attempted) {
             CarrierThread ct = (CarrierThread) currentCarrierThread();
-            ForkJoinPools.endCompensatedBlock(ct.getPool(), compensateReturn);
             ct.endBlocking();
         }
     }
-
-    /**
-     * Defines static methods to invoke non-public ForkJoinPool methods via the
-     * shared secret support.
-     */
-    private static class ForkJoinPools {
-        private static final JavaUtilConcurrentFJPAccess FJP_ACCESS =
-                SharedSecrets.getJavaUtilConcurrentFJPAccess();
-        static long beginCompensatedBlock(ForkJoinPool pool) {
-            return FJP_ACCESS.beginCompensatedBlock(pool);
-        }
-        static void endCompensatedBlock(ForkJoinPool pool, long post) {
-            FJP_ACCESS.endCompensatedBlock(pool, post);
-        }
-    }
-
 }
