WIP

Author: bbrockbernd

atomicfu/build.gradle.kts

@@ -119,7 +119,7 @@ kotlin {
 
         jvmTest {
             dependencies {
-                implementation("org.jetbrains.kotlinx:lincheck:2.35")
+                implementation("org.jetbrains.kotlinx:lincheck:2.38")
                 implementation("org.jetbrains.kotlin:kotlin-reflect")
                 implementation("org.jetbrains.kotlin:kotlin-test")
                 implementation("org.jetbrains.kotlin:kotlin-test-junit")

atomicfu/src/concurrentMain/kotlin/kotlinx/atomicfu/locks/Mutex.kt

@@ -2,7 +2,8 @@ package kotlinx.atomicfu.locks
 
 import kotlinx.atomicfu.AtomicRef
 import kotlinx.atomicfu.atomic
-import kotlinx.atomicfu.parking.ThreadParker
+import kotlinx.atomicfu.parking.KThread
+import kotlinx.atomicfu.parking.Parker
 import kotlinx.atomicfu.parking.currentThreadId
 
 internal class NativeMutex {
@@ -62,7 +63,7 @@ internal class NativeMutex {
         // Remove head
         if (newState > 1) {
             val prevNode = parkingQueue.enqueue()
-            prevNode.parker.park()
+            prevNode.nodeWait()
             parkingQueue.dequeue()
             owningThread.value = currentThreadId
             holdCount.incrementAndGet()
@@ -87,7 +88,7 @@ internal class NativeMutex {
         // If waiters wake up the first in line. The woken up thread will dequeue the node.
         if (currentState > 0) {
             val nextParker = parkingQueue.getHead()
-            nextParker.parker.unpark()
+            nextParker.nodeWake()
             return
         }
     }
@@ -144,7 +145,35 @@ internal class NativeMutex {
     }
 
     private class Node {
-        val parker = ThreadParker()
+        val parker = atomic<Any>(Empty)
         val next = atomic<Node?>(null)
+        
+        fun nodeWait() {
+            while (true) {
+                when (parker.value) {
+                    Empty -> if (parker.compareAndSet(Empty, KThread.currentThread())) Parker.park()
+                    is KThread -> Parker.park()
+                    Woken -> return
+                }
+            }
+        }
+        
+        fun nodeWake() {
+            while (true) {
+                when (val currentState = parker.value) {
+                    Empty -> if (parker.compareAndSet(Empty, Woken)) return
+                    is KThread -> if (parker.compareAndSet(currentState, Woken)) {
+                        Parker.unpark(currentState)
+                        return
+                    }
+                    Woken -> throw IllegalStateException("Node is already woken")
+                }
+            }
+        }
     }
+    
+    private object Empty 
+    private object Woken
+    
+    
 }

atomicfu/src/concurrentMain/kotlin/kotlinx/atomicfu/parking/ThreadParker.kt

@@ -7,12 +7,15 @@ import kotlin.time.TimeSource.Monotonic
 /**
  * Multiplatform thread parker.
  */
-internal class ThreadParker {
+internal class ThreadParker(private val owningThread: KThread) {
     private val delegator = ParkingDelegator
     private val state = atomic<ParkingState>(Free)
 
-    fun park() = parkWith({ false }) { data ->
-        delegator.wait(data) { state.value is Parked }
+    fun park() {
+        check(owningThread == KThread.currentThread()) { "Parking on other threads parker" }
+        parkWith({ false }) { data ->
+            delegator.wait(data) { state.value is Parked }
+        }
     }
 
     fun parkNanos(nanos: Long) {

atomicfu/src/jvmMain/kotlin/kotlinx/atomicfu/parking/KThread.kt

@@ -1,7 +1,7 @@
 package kotlinx.atomicfu.parking
 
 actual class KThread internal actual constructor() {
-    internal val parker = ThreadParker()
+    internal val parker = ThreadParker(this)
     actual companion object {
         actual fun currentThread(): KThread = localKThread.get()
     }

atomicfu/src/jvmTest/kotlin/kotlinx/atomicfu/locks/NativeMutexLincheckReentrantTest.kt

@@ -1,8 +1,8 @@
 import kotlinx.atomicfu.locks.NativeMutex
-import org.jetbrains.kotlinx.lincheck.LoggingLevel
 import org.jetbrains.kotlinx.lincheck.annotations.Operation
 import org.jetbrains.kotlinx.lincheck.check
 import org.jetbrains.kotlinx.lincheck.strategy.managed.modelchecking.ModelCheckingOptions
+import org.jetbrains.kotlinx.lincheck.util.LoggingLevel
 import kotlin.test.Test
 
 class NativeMutexLincheckReentrantTest {

atomicfu/src/jvmTest/kotlin/kotlinx/atomicfu/locks/NativeMutexLincheckTest.kt

@@ -1,8 +1,8 @@
 import kotlinx.atomicfu.locks.NativeMutex
-import org.jetbrains.kotlinx.lincheck.LoggingLevel
 import org.jetbrains.kotlinx.lincheck.annotations.Operation
 import org.jetbrains.kotlinx.lincheck.check
 import org.jetbrains.kotlinx.lincheck.strategy.managed.modelchecking.ModelCheckingOptions
+import org.jetbrains.kotlinx.lincheck.util.LoggingLevel
 import kotlin.test.Test
 
 class NativeMutexLincheckTest {

atomicfu/src/nativeMain/kotlin/kotlinx/atomicfu/parking/KThread.kt

@@ -3,7 +3,7 @@ package kotlinx.atomicfu.parking
 import kotlinx.atomicfu.atomic
 
 actual class KThread internal actual constructor() {
-    internal val parker: ThreadParker = ThreadParker()
+    internal val parker: ThreadParker = ThreadParker(this)
     actual companion object {
         actual fun currentThread(): KThread = thisKThread
     }