diff --git a/kotlinx-coroutines-core/common/src/sync/Semaphore.kt b/kotlinx-coroutines-core/common/src/sync/Semaphore.kt
index 6ab377d..a9df15c 100644
--- a/kotlinx-coroutines-core/common/src/sync/Semaphore.kt
+++ b/kotlinx-coroutines-core/common/src/sync/Semaphore.kt
@@ -166,7 +166,8 @@
     private val index: Int
 ) : CancelHandler() {
     override fun invoke(cause: Throwable?) {
-        semaphore.incPermits()
+        val p = semaphore.incPermits()
+        if (p >= 0) return
         if (segment.cancel(index)) return
         semaphore.resumeNextFromQueue()
     }
diff --git a/kotlinx-coroutines-core/jvm/test/sync/SemaphoreStressTest.kt b/kotlinx-coroutines-core/jvm/test/sync/SemaphoreStressTest.kt
index cdfcc6b..e872b52 100644
--- a/kotlinx-coroutines-core/jvm/test/sync/SemaphoreStressTest.kt
+++ b/kotlinx-coroutines-core/jvm/test/sync/SemaphoreStressTest.kt
@@ -2,6 +2,7 @@
 
 import kotlinx.coroutines.*
 import org.junit.Test
+import org.junit.After
 import kotlin.test.assertEquals
 
 class SemaphoreStressTest : TestBase() {
@@ -57,4 +58,39 @@
         semaphore.release()
         assertEquals(1, semaphore.availablePermits)
     }
-}
\ No newline at end of file
+
+    /**
+     * This checks if repeated releases that race with cancellations put
+     * the semaphore into an incorrect state where permits are leaked.
+     */
+    @Test
+    fun stressReleaseCancelRace() = runTest {
+        val n = 10_000 * stressTestMultiplier
+        val semaphore = Semaphore(1, 1)
+        newSingleThreadContext("SemaphoreStressTest").use { pool ->
+            repeat (n) {
+                // Initially, we hold the permit and no one else can `acquire`,
+                // otherwise it's a bug.
+                assertEquals(0, semaphore.availablePermits)
+                var job1_entered_critical_section = false
+                val job1 = launch(start = CoroutineStart.UNDISPATCHED) {
+                    semaphore.acquire()
+                    job1_entered_critical_section = true
+                    semaphore.release()
+                }
+                // check that `job1` didn't finish the call to `acquire()`
+                assertEquals(false, job1_entered_critical_section)
+                val job2 = launch(pool) {
+                    semaphore.release()
+                }
+                // Because `job2` executes in a separate thread, this
+                // cancellation races with the call to `release()`.
+                job1.cancelAndJoin()
+                job2.join()
+                assertEquals(1, semaphore.availablePermits)
+                semaphore.acquire()
+            }
+        }
+    }
+
+}