Basic Channel interfaces and RendezvousChannel implementation
diff --git a/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/CancellableContinuation.kt b/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/CancellableContinuation.kt
index 64d815b..4daf5f1 100644
--- a/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/CancellableContinuation.kt
+++ b/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/CancellableContinuation.kt
@@ -20,15 +20,37 @@
* Returns `true` if this continuation was cancelled. It implies that [isActive] is `false`.
*/
val isCancelled: Boolean
+
+ /**
+ * Tries to resume this continuation with a given value and returns `true` if it was successful,
+ * or `false` otherwise (it was already resumed or cancelled).
+ *
+ * An optional [onSuccess] callback is invoked with [value] as its parameter after the state of this continuation
+ * is updated (so that is cannot be cancelled anymore), but before it is actually resumed.
+ */
+ fun tryResume(value: T, onSuccess: ((Any?) -> Unit)? = null): Boolean
+
+ /**
+ * Makes this continuation cancellable. Use it with `holdCancellability` optional parameter to
+ * [suspendCancellableCoroutine] function. It throws [IllegalStateException] if invoked more than once.
+ */
+ fun initCancellability()
}
/**
* Suspend coroutine similar to [suspendCoroutine], but provide an implementation of [CancellableContinuation] to
* the [block]. This function throws [CancellationException] if the coroutine is cancelled while suspended.
+ *
+ * If [holdCancellability] optional parameter is `true`, then the coroutine is suspended, but it is not
+ * cancellable until [CancellableContinuation.initCancellability] is invoked.
*/
-public inline suspend fun <T> suspendCancellableCoroutine(crossinline block: (CancellableContinuation<T>) -> Unit): T =
+public inline suspend fun <T> suspendCancellableCoroutine(
+ holdCancellability: Boolean = false,
+ crossinline block: (CancellableContinuation<T>) -> Unit
+): T =
suspendCoroutineOrReturn { cont ->
val safe = SafeCancellableContinuation(cont, getParentJobOrAbort(cont))
+ if (!holdCancellability) safe.initCancellability()
block(safe)
safe.getResult()
}
@@ -63,7 +85,9 @@
const val YIELD = 3 // used by cancellable "yield"
}
- init { initParentJob(parentJob) }
+ override fun initCancellability() {
+ initParentJob(parentJob)
+ }
fun getResult(): Any? {
val decision = this.decision // volatile read
@@ -80,6 +104,16 @@
override val isCancelled: Boolean
get() = getState() is Cancelled
+ override fun tryResume(value: T, onSuccess: ((Any?) -> Unit)?): Boolean {
+ while (true) { // lock-free loop on state
+ val state = getState() // atomic read
+ when (state) {
+ is Active -> if (updateState(state, value, onSuccess)) return true
+ else -> return false // cannot resume -- not active anymore
+ }
+ }
+ }
+
@Suppress("UNCHECKED_CAST")
override fun afterCompletion(state: Any?) {
val decision = this.decision // volatile read
diff --git a/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/Job.kt b/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/Job.kt
index 8d767b1..d34edc8 100644
--- a/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/Job.kt
+++ b/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/Job.kt
@@ -213,14 +213,16 @@
/**
* Tries to update current [state][getState] of this job.
*/
- fun updateState(expect: Any, update: Any?): Boolean {
+ fun updateState(expect: Any, update: Any?, onSuccess: ((Any?) -> Unit)? = null): Boolean {
require(expect is Active && update !is Active) // only active -> inactive transition is allowed
if (!STATE.compareAndSet(this, expect, update)) return false
// #1. Update linked state before invoking completion handlers
onStateUpdate(update)
// #2. Unregister from parent job
registration?.unregister() // volatile read registration _after_ state was updated
- // #3. Invoke completion handlers
+ // #3. Additional (optional) callback
+ onSuccess?.invoke(update)
+ // #4. Invoke completion handlers
val reason = (update as? CompletedExceptionally)?.cancelReason
var completionException: Throwable? = null
when (expect) {
@@ -242,7 +244,7 @@
// otherwise -- do nothing (Empty)
else -> check(expect == Empty)
}
- // #4. Do other (overridable) processing after completion handlers
+ // #5. Do other (overridable) processing after completion handlers
completionException?.let { handleCompletionException(it) }
afterCompletion(update)
return true
diff --git a/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/channels/Channel.kt b/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/channels/Channel.kt
new file mode 100644
index 0000000..ef96c21
--- /dev/null
+++ b/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/channels/Channel.kt
@@ -0,0 +1,167 @@
+package kotlinx.coroutines.experimental.channels
+
+import kotlinx.coroutines.experimental.CancellationException
+import kotlinx.coroutines.experimental.CoroutineScope
+import kotlinx.coroutines.experimental.Job
+import kotlinx.coroutines.experimental.yield
+import java.util.*
+
+/**
+ * Sender's interface to [Channel].
+ */
+public interface SendChannel<in E> {
+ /**
+ * Returns `true` if this channel was closed by invocation of [close] and thus
+ * the [send] attempt will throw [ClosedSendChannelException].
+ */
+ public val isClosedForSend: Boolean
+
+ /**
+ * Returns `true` if the channel is full (out of capacity) and the [send] attempt will suspend.
+ * This function returns `false` for [isClosedForSend] channel.
+ */
+ public val isFull: Boolean
+
+ /**
+ * Adds [element] into to this queue, suspending the caller while this queue [isFull],
+ * or throws [ClosedSendChannelException] if the channel [isClosedForSend].
+ *
+ * This suspending function is cancellable. If the [Job] of the current coroutine is completed while this
+ * function is suspended, this function immediately resumes with [CancellationException].
+ * Cancellation of suspended send is *atomic* -- when this function
+ * throws [CancellationException] it means that the [element] was not sent to this channel.
+ *
+ * Note, that this function does not check for cancellation when it is not suspended.
+ * Use [yield] or [CoroutineScope.isActive] to periodically check for cancellation in tight loops if needed.
+ */
+ public suspend fun send(element: E)
+
+ /**
+ * Adds [element] into this queue if it is possible to do so immediately without violating capacity restrictions
+ * and returns `true`. Otherwise, it returns `false` immediately
+ * or throws [ClosedSendChannelException] if the channel [isClosedForSend].
+ */
+ public fun offer(element: E): Boolean
+
+ /**
+ * Closes this channel. This is an idempotent operation -- repeated invocations of this function have no effect.
+ * Conceptually, its sends a special close token of this channel. Immediately after invocation of this function
+ * [isClosedForSend] starts returning `true`. However, [isClosedForReceive][ReceiveChannel.isClosedForReceive]
+ * on the side of [ReceiveChannel] starts returning `true` only after all previously sent elements
+ * are received.
+ */
+ public fun close()
+}
+
+/**
+ * Receiver's interface to [Channel].
+ */
+public interface ReceiveChannel<out E> {
+ /**
+ * Returns `true` if this channel was closed by invocation of [close][SendChannel.close] on the [SendChannel]
+ * side and all previously sent items were already received, so that the [receive] attempt will
+ * throw [ClosedReceiveChannelException].
+ */
+ public val isClosedForReceive: Boolean
+
+ /**
+ * Returns `true` if the channel is empty (contains no elements) and the [receive] attempt will suspend.
+ * This function returns `false` for [isClosedForReceive] channel.
+ */
+ public val isEmpty: Boolean
+
+ /**
+ * Retrieves and removes the element from this channel suspending the caller while this channel [isEmpty]
+ * or throws [ClosedReceiveChannelException] if the channel [isClosedForReceive].
+ *
+ * This suspending function is cancellable. If the [Job] of the current coroutine is completed while this
+ * function is suspended, this function immediately resumes with [CancellationException].
+ * Cancellation of suspended receive is *atomic* -- when this function
+ * throws [CancellationException] it means that the element was not retrieved from this channel.
+ *
+ * Note, that this function does not check for cancellation when it is not suspended.
+ * Use [yield] or [CoroutineScope.isActive] to periodically check for cancellation in tight loops if needed.
+ */
+ public suspend fun receive(): E
+
+ /**
+ * Retrieves and removes the element from this channel suspending the caller while this channel [isEmpty]
+ * or returns `null` if the channel [isClosedForReceive].
+ *
+ * This suspending function is cancellable. If the [Job] of the current coroutine is completed while this
+ * function is suspended, this function immediately resumes with [CancellationException].
+ * Cancellation of suspended receive is *atomic* -- when this function
+ * throws [CancellationException] it means that the element was not retrieved from this channel.
+ *
+ * Note, that this function does not check for cancellation when it is not suspended.
+ * Use [yield] or [CoroutineScope.isActive] to periodically check for cancellation in tight loops if needed.
+ */
+ public suspend fun receiveOrNull(): E?
+
+ /**
+ * Retrieves and removes the head of this queue, or returns `null` if this queue [isEmpty]
+ * or [isClosedForReceive].
+ */
+ public fun pool(): E?
+
+ /**
+ * Returns new iterator to receive elements from this channels using `for` loop.
+ */
+ public operator fun iterator(): ChannelIterator<E>
+}
+
+/**
+ * Iterator for [ReceiveChannel]. Instances of this interface are *not thread-safe* and shall not be used
+ * from concurrent coroutines.
+ */
+public interface ChannelIterator<out E> {
+ /**
+ * Returns `true` if the channel has more elements suspending the caller while this channel
+ * [isEmpty][ReceiveChannel.isEmpty] or `false` [ClosedReceiveChannelException] if the channel
+ * [isClosedForReceive][ReceiveChannel.isClosedForReceive].
+ * This function retrieves and removes the element from this channel for the subsequent invocation
+ * of [next].
+ *
+ * This suspending function is cancellable. If the [Job] of the current coroutine is completed while this
+ * function is suspended, this function immediately resumes with [CancellationException].
+ * Cancellation of suspended receive is *atomic* -- when this function
+ * throws [CancellationException] it means that the element was not retrieved from this channel.
+ *
+ * Note, that this function does not check for cancellation when it is not suspended.
+ * Use [yield] or [CoroutineScope.isActive] to periodically check for cancellation in tight loops if needed.
+ */
+ public suspend operator fun hasNext(): Boolean
+
+ /**
+ * Retrieves and removes the element from this channel suspending the caller while this channel
+ * [isEmpty][ReceiveChannel.isEmpty] or throws [ClosedReceiveChannelException] if the channel
+ * [isClosedForReceive][ReceiveChannel.isClosedForReceive].
+ *
+ * This suspending function is cancellable. If the [Job] of the current coroutine is completed while this
+ * function is suspended, this function immediately resumes with [CancellationException].
+ * Cancellation of suspended receive is *atomic* -- when this function
+ * throws [CancellationException] it means that the element was not retrieved from this channel.
+ *
+ * Note, that this function does not check for cancellation when it is not suspended.
+ * Use [yield] or [CoroutineScope.isActive] to periodically check for cancellation in tight loops if needed.
+ */
+ public suspend operator fun next(): E
+}
+
+/**
+ * Channel is a non-blocking primitive for communication between sender using [SendChannel] and receiver using [ReceiveChannel].
+ * Conceptually, a channel is similar to [BlockingQueue][java.util.concurrent.BlockingQueue],
+ * but it has suspending operations instead of blocking ones and it can be closed.
+ */
+public interface Channel<E> : SendChannel<E>, ReceiveChannel<E>
+
+/**
+ * Indicates attempt to [send][SendChannel.send] on [isClosedForSend][SendChannel.isClosedForSend] channel.
+ */
+public class ClosedSendChannelException : IllegalStateException()
+
+/**
+ * Indicates attempt to [receive][ReceiveChannel.receive] on [isClosedForReceive][ReceiveChannel.isClosedForReceive]
+ * channel.
+ */
+public class ClosedReceiveChannelException : NoSuchElementException()
diff --git a/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/channels/RendezvousChannel.kt b/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/channels/RendezvousChannel.kt
new file mode 100644
index 0000000..57095cc
--- /dev/null
+++ b/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/channels/RendezvousChannel.kt
@@ -0,0 +1,284 @@
+package kotlinx.coroutines.experimental.channels
+
+import kotlinx.coroutines.experimental.CancellableContinuation
+import kotlinx.coroutines.experimental.internal.LockFreeLinkedListHead
+import kotlinx.coroutines.experimental.internal.LockFreeLinkedListNode
+import kotlinx.coroutines.experimental.removeOnCompletion
+import kotlinx.coroutines.experimental.suspendCancellableCoroutine
+
+/**
+ * Rendezvous channel. This channel does not have any buffer at all. An element is transferred from sender
+ * to receiver only when [send] and [receive] invocations meet in time (rendezvous), so [send] suspends
+ * until another coroutine invokes [receive] and [receive] suspends until another coroutine invokes [send].
+ */
+public class RendezvousChannel<E> : Channel<E> {
+ private val queue = LockFreeLinkedListHead()
+
+ // ------ SendChannel ------
+
+ override val isClosedForSend: Boolean get() = queue.prev() is Closed<*>
+
+ override val isFull: Boolean get() = queue.next() !is ReceiveOrClosed<*>
+
+ suspend override fun send(element: E) {
+ // fast path if receive is already waiting for rendezvous
+ while (true) { // loop while there are receive waiters
+ val receive = takeFirstReceiveOrPeekClosed() ?: break
+ if (receive.tryResumeReceiveFromSend(element)) return // resumed it successfully
+ }
+ // slow-path does suspend
+ return suspendCancellableCoroutine(true) sc@ { cont ->
+ while (true) {
+ val send = SendElement(cont, element) // must allocate fresh element on each loop
+ if (queue.addLastIfPrev(send) { it !is Receive<*> && it !is Closed<*> }) {
+ cont.initCancellability() // make it properly cancellable
+ cont.removeOnCompletion(send)
+ return@sc
+ }
+ // hm... there are already receivers (maybe), so try taking first
+ takeFirstReceiveOrPeekClosed()?.also { receive ->
+ if (receive.tryResumeReceiveFromSend(element, cont)) return@sc
+ }
+ }
+ }
+ }
+
+ override fun offer(element: E): Boolean {
+ takeFirstReceiveOrPeekClosed()?.apply {
+ tryResumeReceiveFromSend(element)
+ return true
+ }
+ return false
+ }
+
+ override fun close() {
+ while (true) {
+ val receive = takeFirstReceiveOrPeekClosed()
+ if (receive == null) {
+ // queue empty or has only senders -- try add last "Closed" item to the queue
+ if (queue.addLastIfPrev(Closed<E>()) { it !is Closed<*> }) return
+ }
+ if (receive is Closed<*>) return // already marked as closed -- nothing to do
+ receive as Receive<E> // type assertion
+ receive.resumeReceiveClosed()
+ }
+ }
+
+ private fun takeFirstReceiveOrPeekClosed(): ReceiveOrClosed<E>? =
+ queue.removeFirstIfIsInstanceOfOrPeekIf<ReceiveOrClosed<E>> { it is Closed<*> }
+
+ // ------ ReceiveChannel ------
+
+ override val isClosedForReceive: Boolean get() = queue.next() is Closed<*>
+
+ override val isEmpty: Boolean get() = queue.next() !is Send<*>
+
+ suspend override fun receive(): E {
+ // fast path if send is already waiting for rendezvous or closed
+ while (true) { // loop while there are send waiters
+ val send = takeFirstSendOrPeekClosed() ?: break
+ if (send.tryResumeSend()) return send.element // resumed it successfully
+ }
+ // slow-path does suspend
+ return suspendCancellableCoroutine(true) sc@ { cont ->
+ while (true) {
+ val receive = ReceiveNonNull(cont) // must allocate fresh element on each loop
+ if (queue.addLastIfPrev(receive) { it !is Send<*> }) {
+ cont.initCancellability() // make it properly cancellable
+ cont.removeOnCompletion(receive)
+ return@sc
+ }
+ // hm... there are already senders (maybe), so try taking first
+ takeFirstSendOrPeekClosed()?.also { send ->
+ if (send.tryResumeSend()) {
+ send.resumeWithElement(cont)
+ return@sc
+ }
+ }
+ }
+ }
+ }
+
+ suspend override fun receiveOrNull(): E? {
+ // fast path if send is already waiting for rendezvous or closed
+ while (true) { // loop while there are send waiters
+ val send = takeFirstSendOrPeekClosed() ?: break
+ if (send.tryResumeSend()) return send.elementOrNull // resumed it successfully
+ }
+ // slow-path does suspend
+ return suspendCancellableCoroutine(true) sc@ { cont ->
+ while (true) {
+ val receive = ReceiveOrNull(cont) // must allocate fresh element on each loop
+ if (queue.addLastIfPrev(receive) { it !is Send<*> }) {
+ cont.initCancellability() // make it properly cancellable
+ cont.removeOnCompletion(receive)
+ return@sc
+ }
+ // hm... there are already senders (maybe), so try taking first
+ takeFirstSendOrPeekClosed()?.also { send ->
+ if (send.tryResumeSend()) {
+ send.resumeWithElementOrNull(cont)
+ return@sc
+ }
+ }
+ }
+ }
+ }
+
+ override fun pool(): E? {
+ while (true) {
+ val waiter = takeFirstSendOrPeekClosed() ?: return null
+ if (waiter.tryResumeSend()) return waiter.element
+ }
+ }
+
+ override fun iterator(): ChannelIterator<E> = Iterator(this)
+
+ private fun takeFirstSendOrPeekClosed(): Send<E>? =
+ queue.removeFirstIfIsInstanceOfOrPeekIf<Send<E>> { it is Closed<*> }
+
+ private companion object {
+ val IS_UNKNOWN = 0
+ val IS_HAS_VALUE = 1
+ val IS_CLOSED = 2
+ }
+
+ private class Iterator<E>(val channel: RendezvousChannel<E>) : ChannelIterator<E> {
+ var state: Int = IS_UNKNOWN
+ var value: E? = null
+
+ suspend override fun hasNext(): Boolean {
+ when (state) {
+ IS_HAS_VALUE -> return true
+ IS_CLOSED -> return false
+ }
+ // fast path if send is already waiting for rendezvous
+ while (true) { // loop while there are send waiters
+ val send = channel.takeFirstSendOrPeekClosed() ?: break
+ if (send.tryResumeSend()) return updateStateWithSend(send)
+ }
+ // slow-path does suspend
+ return suspendCancellableCoroutine(true) sc@ { cont ->
+ while (true) {
+ val receive = ReceiveHasNext(this, cont) // must allocate fresh element on each loop
+ if (channel.queue.addLastIfPrev(receive) { it !is Send<*> }) {
+ cont.initCancellability() // make it properly cancellable
+ cont.removeOnCompletion(receive)
+ return@sc
+ }
+ // hm... there are already senders (maybe), so try taking first
+ channel.takeFirstSendOrPeekClosed()?.also { send ->
+ if (send.tryResumeSend()) {
+ cont.resume(updateStateWithSend(send))
+ return@sc
+ }
+ }
+ }
+ }
+ }
+
+ private fun updateStateWithSend(send: Send<E>): Boolean {
+ if (send is Closed<*>) {
+ state = IS_CLOSED
+ return false
+ } else {
+ state = IS_HAS_VALUE
+ value = send.element
+ return true
+ }
+ }
+
+ suspend override fun next(): E {
+ when (state) {
+ IS_HAS_VALUE -> {
+ val value = this.value as E
+ this.state = IS_UNKNOWN
+ this.value = null
+ return value
+ }
+ IS_CLOSED -> throw ClosedReceiveChannelException()
+ }
+ // rare case when hasNext was not invoked yet -- just delegate to receive (leave state as IS_UNKNOWN)
+ return channel.receive()
+ }
+ }
+
+ private abstract class Send<out E> : LockFreeLinkedListNode() {
+ abstract val element: E
+ abstract val elementOrNull: E?
+ abstract fun tryResumeSend(): Boolean
+ abstract fun resumeWithElement(cont: CancellableContinuation<E>)
+ abstract fun resumeWithElementOrNull(cont: CancellableContinuation<E?>)
+ }
+
+ private class SendElement<out E>(
+ val cont: CancellableContinuation<Unit>,
+ override val element: E
+ ) : Send<E>() {
+ override val elementOrNull: E? get() = element
+ override fun tryResumeSend(): Boolean = cont.tryResume(Unit)
+ override fun resumeWithElement(cont: CancellableContinuation<E>) = cont.resume(element)
+ override fun resumeWithElementOrNull(cont: CancellableContinuation<E?>) = cont.resume(element)
+ }
+
+ private interface ReceiveOrClosed<in E> {
+ fun tryResumeReceiveFromSend(value: E): Boolean
+ fun tryResumeReceiveFromSend(value: E, cont: CancellableContinuation<Unit>): Boolean
+ }
+
+ private class Closed<E> : Send<E>(), ReceiveOrClosed<E> {
+ override val element: E get() = throw ClosedReceiveChannelException()
+ override val elementOrNull: E? get() = null
+ override fun tryResumeSend(): Boolean = true
+ override fun resumeWithElement(cont: CancellableContinuation<E>) = cont.resumeWithException(ClosedReceiveChannelException())
+ override fun resumeWithElementOrNull(cont: CancellableContinuation<E?>) = cont.resume(null)
+ override fun tryResumeReceiveFromSend(value: E): Boolean = throw ClosedSendChannelException()
+ override fun tryResumeReceiveFromSend(value: E, cont: CancellableContinuation<Unit>): Boolean {
+ cont.resumeWithException(ClosedSendChannelException())
+ return true
+ }
+ }
+
+ private abstract class Receive<in E> : LockFreeLinkedListNode(), ReceiveOrClosed<E> {
+ override fun tryResumeReceiveFromSend(value: E, cont: CancellableContinuation<Unit>): Boolean {
+ if (tryResumeReceiveFromSend(value)) {
+ cont.resume(Unit)
+ return true
+ }
+ return false
+ }
+ abstract fun resumeReceiveClosed()
+ }
+
+ private class ReceiveNonNull<in E>(val cont: CancellableContinuation<E>) : Receive<E>() {
+ override fun tryResumeReceiveFromSend(value: E): Boolean = cont.tryResume(value)
+ override fun resumeReceiveClosed() = cont.resumeWithException(ClosedReceiveChannelException())
+ }
+
+ private class ReceiveOrNull<in E>(val cont: CancellableContinuation<E?>) : Receive<E>() {
+ override fun tryResumeReceiveFromSend(value: E): Boolean = cont.tryResume(value)
+ override fun resumeReceiveClosed() = cont.resume(null)
+ }
+
+ private class ReceiveHasNext<E>(
+ val iterator: Iterator<E>,
+ val cont: CancellableContinuation<Boolean>
+ ) : Receive<E>(), (Any?) -> Unit {
+ override fun tryResumeReceiveFromSend(value: E): Boolean {
+ iterator.value = value // tentative value (may fail to resume with it)
+ return cont.tryResume(true, this)
+ }
+
+ override fun resumeReceiveClosed() {
+ cont.tryResume(false, this)
+ }
+
+ // callback for tryResume onSuccess
+ override fun invoke(hasNext: Any?) {
+ hasNext as Boolean // try assertion -- that is the value we pass
+ iterator.state = if (hasNext) IS_HAS_VALUE else IS_CLOSED
+ if (!hasNext) iterator.value = null // cleanup tentative value
+ }
+ }
+}
+
diff --git a/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/channels/RendezvousChannelAtomicityStressTest.kt b/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/channels/RendezvousChannelAtomicityStressTest.kt
new file mode 100644
index 0000000..5998e08
--- /dev/null
+++ b/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/channels/RendezvousChannelAtomicityStressTest.kt
@@ -0,0 +1,103 @@
+package kotlinx.coroutines.experimental.channels
+
+import kotlinx.coroutines.experimental.*
+import org.junit.Test
+import java.util.*
+import kotlin.test.assertEquals
+
+class RendezvousChannelAtomicityStressTest {
+ val TEST_DURATION = 3000L
+
+ val channel = RendezvousChannel<Int>()
+ val senderDone = RendezvousChannel<Boolean>()
+ val receiverDone = RendezvousChannel<Boolean>()
+
+ var lastSent = 0
+ var lastReceived = 0
+
+ var stoppedSender = 0
+ var stoppedReceiver = 0
+
+ var missedCnt = 0
+ var dupCnt = 0
+
+ lateinit var sender: Job
+ lateinit var receiver: Job
+
+ @Test
+ fun testStress() = runBlocking {
+ val deadline = System.currentTimeMillis() + TEST_DURATION
+ launchSender()
+ launchReceiver()
+ val rnd = Random()
+ while (System.currentTimeMillis() < deadline) {
+ when (rnd.nextInt(4)) {
+ 0 -> { // cancel & restart sender
+ stopSender()
+ launchSender()
+ }
+ 1 -> { // cancel & restrat receiver
+ stopReceier()
+ launchReceiver()
+ }
+ 2 -> yield() // just yield (burn a little time)
+ 3 -> delay(1L) // delay for more a bit
+ }
+ }
+ stopSender()
+ stopReceier()
+ println(" Sent $lastSent ints to channel")
+ println(" Received $lastReceived ints from channel")
+ println(" Stopped sender $stoppedSender times")
+ println("Stopped receiver $stoppedReceiver times")
+ println(" Missed $missedCnt ints")
+ println(" Duplicated $dupCnt ints")
+ assertEquals(0, missedCnt)
+ assertEquals(0, dupCnt)
+ assertEquals(lastSent, lastReceived)
+ }
+
+ fun launchSender() {
+ sender = launch(CommonPool) {
+ try {
+ while (true) {
+ val trySend = lastSent + 1
+ channel.send(trySend)
+ lastSent = trySend // update on success
+ }
+ } finally {
+ run(NonCancellable) { senderDone.send(true) }
+ }
+ }
+ }
+
+ suspend fun stopSender() {
+ stoppedSender++
+ sender.cancel()
+ senderDone.receive()
+ }
+
+ fun launchReceiver() {
+ receiver = launch(CommonPool) {
+ try {
+ while (true) {
+ val received = channel.receive()
+ val expected = lastReceived + 1
+ if (received > expected)
+ missedCnt++
+ if (received < expected)
+ dupCnt++
+ lastReceived = received
+ }
+ } finally {
+ run(NonCancellable) { receiverDone.send(true) }
+ }
+ }
+ }
+
+ suspend fun stopReceier() {
+ stoppedReceiver++
+ receiver.cancel()
+ receiverDone.receive()
+ }
+}
diff --git a/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/channels/RendezvousChannelMultipleReceiversStressTest.kt b/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/channels/RendezvousChannelMultipleReceiversStressTest.kt
new file mode 100644
index 0000000..a8269c3
--- /dev/null
+++ b/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/channels/RendezvousChannelMultipleReceiversStressTest.kt
@@ -0,0 +1,84 @@
+package kotlinx.coroutines.experimental.channels
+
+import kotlinx.coroutines.experimental.CommonPool
+import kotlinx.coroutines.experimental.join
+import kotlinx.coroutines.experimental.launch
+import kotlinx.coroutines.experimental.runBlocking
+import org.junit.Test
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class RendezvousChannelMultipleReceiversStressTest {
+ val nEvents = 1_000_000
+ val nReceivers = 6
+
+ val channel = RendezvousChannel<Int>()
+ val completedSuccessfully = AtomicInteger()
+ val dupes = AtomicInteger()
+ val received = ConcurrentHashMap<Int,Int>()
+ val receivedBy = IntArray(nReceivers)
+
+ @Test
+ fun testStress() = runBlocking {
+ val receivers = List(nReceivers) { receiverIndex ->
+ // different event receivers use different code
+ launch(CommonPool) {
+ when (receiverIndex % 3) {
+ 0 -> doReceive(receiverIndex)
+ 1 -> doReceiveOrNull(receiverIndex)
+ 2 -> doIterator(receiverIndex)
+ }
+ completedSuccessfully.incrementAndGet()
+ }
+ }
+ repeat(nEvents) {
+ channel.send(it)
+ }
+ channel.close()
+ receivers.forEach { it.join() }
+ println("Completed successfully ${completedSuccessfully.get()} coroutines")
+ println(" Received ${received.size} events")
+ println(" Received dupes ${dupes.get()}")
+ repeat(nReceivers) { receiveIndex ->
+ println(" Received by #$receiveIndex ${receivedBy[receiveIndex]}")
+ }
+ assertEquals(nReceivers, completedSuccessfully.get())
+ assertEquals(0, dupes.get())
+ assertEquals(nEvents, received.size)
+ repeat(nReceivers) { receiveIndex ->
+ assertTrue(receivedBy[receiveIndex] > nEvents / nReceivers / 2, "Should be balanced")
+ }
+ }
+
+ private fun doReceived(event: Int) {
+ if (received.put(event, event) != null) {
+ println("Duplicate event $event")
+ dupes.incrementAndGet()
+ }
+ }
+
+ private suspend fun doReceive(receiverIndex: Int) {
+ while (true) {
+ try { doReceived(channel.receive()) }
+ catch (ex: ClosedReceiveChannelException) { break }
+ receivedBy[receiverIndex]++
+ }
+
+ }
+
+ private suspend fun doReceiveOrNull(receiverIndex: Int) {
+ while (true) {
+ doReceived(channel.receiveOrNull() ?: break)
+ receivedBy[receiverIndex]++
+ }
+ }
+
+ private suspend fun doIterator(receiverIndex: Int) {
+ for (event in channel) {
+ doReceived(event)
+ receivedBy[receiverIndex]++
+ }
+ }
+}
\ No newline at end of file
diff --git a/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/channels/RendezvousChannelTest.kt b/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/channels/RendezvousChannelTest.kt
new file mode 100644
index 0000000..669607e
--- /dev/null
+++ b/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/channels/RendezvousChannelTest.kt
@@ -0,0 +1,126 @@
+package kotlinx.coroutines.experimental.channels
+
+import kotlinx.coroutines.experimental.*
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class RendezvousChannelTest : TestBase() {
+ @Test
+ fun testSimple() = runBlocking {
+ val q = RendezvousChannel<Int>()
+ check(q.isEmpty && q.isFull)
+ expect(1)
+ val sender = launch(context) {
+ expect(4)
+ q.send(1) // suspend -- the first to come to rendezvous
+ expect(7)
+ q.send(2) // does not suspend -- receiver is there
+ expect(8)
+ }
+ expect(2)
+ val receiver = launch(context) {
+ expect(5)
+ check(q.receive() == 1) // does not suspend -- sender was there
+ expect(6)
+ check(q.receive() == 2) // suspends
+ expect(9)
+ }
+ expect(3)
+ sender.join()
+ receiver.join()
+ check(q.isEmpty && q.isFull)
+ finish(10)
+ }
+
+ @Test
+ fun testStress() = runBlocking {
+ val n = 100_000
+ val q = RendezvousChannel<Int>()
+ val sender = launch(context) {
+ for (i in 1..n) q.send(i)
+ expect(2)
+ }
+ val receiver = launch(context) {
+ for (i in 1..n) check(q.receive() == i)
+ expect(3)
+ }
+ expect(1)
+ sender.join()
+ receiver.join()
+ finish(4)
+ }
+
+ @Test
+ fun testClosedReceiveOrNull() = runBlocking {
+ val q = RendezvousChannel<Int>()
+ check(q.isEmpty && q.isFull && !q.isClosedForSend && !q.isClosedForReceive)
+ expect(1)
+ launch(context) {
+ expect(3)
+ assertEquals(42, q.receiveOrNull())
+ expect(4)
+ assertEquals(null, q.receiveOrNull())
+ expect(6)
+ }
+ expect(2)
+ q.send(42)
+ expect(5)
+ q.close()
+ check(!q.isEmpty && !q.isFull && q.isClosedForSend && q.isClosedForReceive)
+ yield()
+ check(!q.isEmpty && !q.isFull && q.isClosedForSend && q.isClosedForReceive)
+ finish(7)
+ }
+
+ @Test
+ fun testClosedExceptions() = runBlocking {
+ val q = RendezvousChannel<Int>()
+ expect(1)
+ launch(context) {
+ expect(4)
+ try { q.receive() }
+ catch (e: ClosedReceiveChannelException) {
+ expect(5)
+ }
+ }
+ expect(2)
+ q.close()
+ expect(3)
+ yield()
+ expect(6)
+ try { q.send(42) }
+ catch (e: ClosedSendChannelException) {
+ finish(7)
+ }
+ }
+
+ @Test
+ fun testOfferAndPool() = runBlocking {
+ val q = RendezvousChannel<Int>()
+ assertFalse(q.offer(1))
+ expect(1)
+ launch(context) {
+ expect(3)
+ assertEquals(null, q.pool())
+ expect(4)
+ assertEquals(2, q.receive())
+ expect(7)
+ assertEquals(null, q.pool())
+ yield()
+ expect(9)
+ assertEquals(3, q.pool())
+ expect(10)
+ }
+ expect(2)
+ yield()
+ expect(5)
+ assertTrue(q.offer(2))
+ expect(6)
+ yield()
+ expect(8)
+ q.send(3)
+ finish(11)
+ }
+}
\ No newline at end of file