SafeCondition

core/src/main/scala-3/com/github/skozlov/commons/scala/concurrent/lock/Condition.scala

@@ -0,0 +1,30 @@
+package com.github.skozlov.commons.scala.concurrent.lock
+
+import com.github.skozlov.commons.scala.time.Deadline
+
+import java.util.concurrent.TimeoutException
+import java.util.concurrent.locks.Condition
+import scala.annotation.tailrec
+
+extension (condition: Condition) {
+  def awaitUninterruptibly(exitCondition: () => Boolean): Unit = {
+    while (!exitCondition()) {
+      condition.awaitUninterruptibly()
+    }
+  }
+
+  @throws[InterruptedException]
+  @throws[TimeoutException]
+  @tailrec
+  def await(exitCondition: () => Boolean)(implicit deadline: Deadline): Unit = {
+    if (!exitCondition()) {
+      if deadline.isOver then throw new TimeoutException(s"Condition was never true before $deadline")
+      if (deadline == Deadline.Inf) {
+        condition.await()
+      } else {
+        condition.awaitNanos(deadline.toTimeout.toNanos)
+      }
+      await(exitCondition)(deadline)
+    }
+  }
+}

core/src/main/scala-3/com/github/skozlov/commons/scala/concurrent/lock/SafeCondition.scala

@@ -0,0 +1,11 @@
+package com.github.skozlov.commons.scala.concurrent.lock
+
+import com.github.skozlov.commons.scala.time.Deadline
+
+import java.util.concurrent.locks.Condition
+
+case class SafeCondition(unsafe: Condition) {
+  def await(exitCondition: () => Boolean)(implicit deadline: Deadline): Unit = unsafe.await(exitCondition)(deadline)
+
+  def signalAll(): Unit = unsafe.signalAll()
+}

core/src/main/scala-3/com/github/skozlov/commons/scala/concurrent/lock/SafeLock.scala

@@ -14,4 +14,6 @@ case class SafeLock(unsafe: ReentrantLock) {
   @throws[InterruptedException]
   @throws[TimeoutException]
   def locking[R](f: () => R)(implicit deadline: Deadline): R = unsafe.locking(f)(deadline)
+
+  def newCondition(): SafeCondition = SafeCondition(unsafe.newCondition())
 }