BasicLock

core/src/main/java/jayo/internal/RealBasicLock.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2025-present, pull-vert and Jayo contributors.
+ * Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package jayo.internal;
+
+import jayo.tools.BasicLock;
+import org.jspecify.annotations.Nullable;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.util.concurrent.locks.LockSupport;
+
+public final class RealBasicLock implements BasicLock {
+    @SuppressWarnings("FieldMayBeFinal")
+    private volatile @Nullable Thread lockingThread = null;
+
+    // VarHandle mechanics
+    private static final VarHandle LOCKING_THREAD;
+
+    static {
+        try {
+            final var l = MethodHandles.lookup();
+            LOCKING_THREAD = l.findVarHandle(RealBasicLock.class, "lockingThread", Thread.class);
+        } catch (ReflectiveOperationException e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
+    @Override
+    public void lock() {
+        final var lockingThread = (Thread) LOCKING_THREAD.getAndSetRelease(this, Thread.currentThread());
+        if (lockingThread != null) {
+            LockSupport.park();
+        }
+    }
+
+    @Override
+    public void unlock() {
+        final var currentThread = Thread.currentThread();
+        final var lockingThread = (Thread) LOCKING_THREAD.compareAndExchangeRelease(this, currentThread, null);
+        if (lockingThread != currentThread) {
+            LockSupport.unpark(lockingThread);
+        }
+    }
+}

core/src/main/java/jayo/internal/SegmentQueue.java

@@ -5,6 +5,7 @@
 
 package jayo.internal;
 
+import jayo.tools.BasicLock;
 import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.Nullable;
 
@@ -13,7 +14,6 @@
 import java.util.Objects;
 import java.util.concurrent.atomic.LongAdder;
 import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.ToIntFunction;
@@ -29,7 +29,7 @@ sealed class SegmentQueue implements AutoCloseable permits WriterSegmentQueue, R
     Segment head = null;
     @Nullable
     Segment tail = null;
-    final @NonNull Lock lock = new ReentrantLock();
+    final @NonNull Lock lock = BasicLock.create();
 
     private final @NonNull LongAdder size = new LongAdder();
 

core/src/main/java/jayo/tools/BasicLock.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2025-present, pull-vert and Jayo contributors.
+ * Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package jayo.tools;
+
+import jayo.internal.RealBasicLock;
+import org.jspecify.annotations.NonNull;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+
+/**
+ * A basic lock that only supports {@link #lock()} and {@link #unlock()}. It is not reentrant and only support 2
+ * concurrent threads.
+ */
+public interface BasicLock extends Lock {
+    static BasicLock create() {
+        return new RealBasicLock();
+    }
+
+    @Override
+    default void lockInterruptibly() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    default boolean tryLock() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    default boolean tryLock(long time, @NonNull TimeUnit unit) {
+        throw new UnsupportedOperationException();
+    }
+
+    @NonNull
+    @Override
+    default Condition newCondition() {
+        throw new UnsupportedOperationException();
+    }
+}