fun onCreate() {
    val user = profile.getUser()
    if (!user.contains("token")) {
        coroutineScope.launch(coroutineExceptionHandler) {
            launch(<http://Dispatchers.IO|Dispatchers.IO>) {
                try {
                    val token = network.fetchToken()
                    // ...
                } finally {
                    withContext(Dispatchers.Main) {
                        view.hideProgressBar()
                    }
                }
            }
        }
    } else {
        // ...
    }
}

network.fetchToken()

runBlocking

runBlockingTest

fun a() {
    Log.i("Log info")
        launch {
            myAtomicLong.set(SystemClock.elapsedRealtime()) 
            Log.i("Log info in launch")
        }
}

GlobalScope.launch {
            val deferred = CompletableDeferred<Unit>()

            Thread {
                val result = doSomething()
                if (result == SUCCESS) {
                    deferred.complete(Unit)
                } else {
                    deferred.completeExceptionally(Exception("oopps"))
                }
            }.start()

            deferred.await()
        }

Job.cancel()

keys.forEach { priority ->
            get(priority)?.forEachLimitedParallel(callable)
                ?: throw IllegalStateException("No list found for priority $priority")
        }

ConflatedBroadcastChannel

val conflated = ConflatedBroadcastChannel<Int>()
val stringConflated: ConflatedBroadcastChannel<String>() = conflated.toStringConflated()

launch {
  stringConflated.consumeEach { println(it) }
}

launch {
  conflated.send(2) // will print "2" (as string)
}

toStringConflated

suspend fun ConflatedBroadcastChannel<Int>.toStringConflated(): ConflatedBroadcastChannel<String> =
    ConflatedBroadcastChannel<String>().apply {
        this@toConflatedString.consumeEach { // map value here }
    }

consumerEach

ConflatedBroadcastChannel<Int>

ConflatedBroadcastChannel<String>()

actor

ConflatedBroadcastChannel

Flow

class CountRepository: CoroutineScope by CoroutineScope(Dispatchers.Default) {

    private val stateChannel = ConflatedBroadcastChannel<Int>(0)
    
    private val actor = actor<Int>(capacity = Channel.UNLIMITED) {
        var count = stateChannel.value

        for (message in channel) {
            count += message
            
            stateChannel.send(count)
        }
    }

    fun states(): ReceiveChannel<Int> = stateChannel.openSubscription()

    fun increment() {
        actor.offer(1)
    }

    fun decrement() {
        actor.offer(-1)
    }
}

class ConflatedTests: CoroutineScope by CoroutineScope(Dispatchers.Unconfined) {

    private val channel = ConflatedBroadcastChannel<Int>()

    @ExperimentalCoroutinesApi
    fun main() = launch {
        launch {
            channel.consumeEach {
                println(it)
            }
        }
        dispatch(channel, 1)
        dispatch(channel, 2)
        dispatch(channel, 3)
        dispatch(channel, 4)
    }

    @ExperimentalCoroutinesApi
    private fun <T> CoroutineScope.dispatch(channel: ConflatedBroadcastChannel<T>, action: T) = launch {
        channel.send(action)
    }
}

1

4

coroutineScope

myDeferred2

myDeferred1

viewModelScope.launch {

            val myDeferred1 = coroutineScope {
                delay(7000)
            }
            val myDeferred2 = coroutineScope {
                delay(2000)
            }
}

async

synchronized

Mutex

broadcastIn

Flow

@ExperimentalCoroutinesApi

@FlowPreview

fun main() {
  val list = listOf("1", "2", "3", "4", "5") //listOf("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15" )
  val threadPool = Executors.newFixedThreadPool(3)!!
  //val threadPoolAsCouritineDispatcher = threadPool.asCoroutineDispatcher()

  fun <A> Iterable<A>.parallelIterWithExecutorAttempt(
      exec: ExecutorService,
      block: (A) -> Unit) {
    this.asIterable().map { exec.submit { block(it) } }.forEach { it.get() }
  }

 suspend fun work(item: String) =
     withContext(Dispatchers.Default) {

       //<https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/jvm/test/guide/example-cancel-07.kt>
       //<https://medium.com/@elizarov/blocking-threads-suspending-coroutines-d33e11bf4761>

       val result = withTimeoutOrNull(timeMillis = 130L) {
          repeat(10) { i ->
            println("ListItem=$item -> I'm sleeping on iteration -> $i ...")
            delay(50L)
            //Thread.sleep(50L) //to mimic non-couroutine external I/O operaion
          }
          println("process=$item ->Done") // will get cancelled before it produces this result
        }
    }

  println("parallelIterWithExecutor")
  runBlocking {
    list.parallelIterWithExecutorAttempt(threadPool) { item ->
      launch {
        work(item)
      } //timeout...
    }
  }
  println("end of life for process") 
}

await()

Mono

Flux