A modern programming language that makes developers happier.

kotlinlang

Why doesn't this deadlock?
```val stream = MutableSharedFlow&lt;Unit&gt;()
val unused = stream.buffer(Channel.RENDEZVOUS).produceIn(GlobalScope)
stream.emit(Unit)```

I think `MutableSharedFlow`  will drop events if there are no subscribers

<https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-shared-flow/index.html>
```in the absence of subscribers emitter never suspends despite BufferOverflow.SUSPEND option and BufferOverflow.DROP_LATEST option does not have effect either```


Yes but isn't the `produceIn` a subscriber?

~If I call `stream.emit(Unit)` 20 times, in a row, it suspends after the 15th `emit`.~  Nvm, it just never suspends.

I got it to suspend at the 65th emission, which seems to indicate a default buffer size somewhere

```stream.buffer(10)```
suspends at the 11th emission so looks like `Channel.RENDEZVOUS` isn't honoured

Tried 200 emissions and it doesn't suspend.

I run this in a junit test:
```  @Test
  fun produceIn() {
    runBlocking {
      val stream = MutableSharedFlow&lt;Unit&gt;()
      val unused = stream.buffer(Channel.RENDEZVOUS).produceIn(GlobalScope)
      var i = 0
      while (true) {
        println("emitting $i")
        stream.emit(Unit)
        i++
      }
    }
  }```


Adding a delay before the loop makes it 65.

SharedFlow doesn't support `RENDEZVOUS` :
```Application of flowOn, buffer with RENDEZVOUS capacity, or cancellable operators to a shared flow has no effect.```


I really don't want to use a channel for this. I guess I don't have a choice.

I guess having a RENDEZVOUS with multiple subscribers was too complex...

There's still the issue of 65 emissions, I wonder where that comes from.

Ah, `buffer(1)`  makes it 2. :face_palm::skin-tone-3:

<https://github.com/Kotlin/kotlinx.coroutines/blob/b231887c3214187cf7f09a74073f84383a487b71/kotlinx-coroutines-core/common/src/channels/Channel.kt#L750|https://github.com/Kotlin/kotlinx.coroutines/blob/b231887c3214187cf7f09a74073f84383a487b71/kotlinx-coroutines-core/common/src/channels/Channel.kt#L750>

<https://github.com/Kotlin/kotlinx.coroutines/blob/65e1b84f742a4fff14c67a11a873a4977a0ba539/kotlinx-coroutines-core/common/src/flow/SharedFlow.kt#L693>

Doesn't seem like a complexity issue, but I'm now wondering why they thought it'd be meaningless.

Must've not realised there would be an interesting default?

It's probable `produceIn` that's wrong I guess.

Opened these two.
<https://github.com/Kotlin/kotlinx.coroutines/issues/2817>
<https://github.com/Kotlin/kotlinx.coroutines/issues/2818>