runCatching

CancellationException

CancellationException

test1()

test2()

async(<http://Dispatchers.IO|Dispatchers.IO>) { [...] }

suspend fun logic() = withContext(<http://Dispatchers.IO|Dispatchers.IO>) { [...] }; async { logic() }

coroutineContext

coroutineContext[Job]

runBlocking {
	fun tt(s: CoroutineScope) = s.launch(start = CoroutineStart.LAZY) { }
	val s = this
	tt(s)
}

There is no event loop. Use runBlocking{...} to start one

runBlocking

val result = runBlocking(MainDispatcher) {
            return@runBlocking "yes"
        }

ViewModel

Account1

Account2

blob

UI

onEach

ViewModel

class SelectAccountViewModel(
    private val startLoadingAccounts: StartLoadingAccounts,
    private val observeAccounts: ObserveAccounts,
    private val loadImage: LoadImage
) : ViewModel(), SupportNavigation<Event<AppNavigation.Command>> {

    val state by lazy { MutableLiveData<List<ChooseProfileView>>() }

    private val accountChannel = Channel<Account>()
    private val imageChannel = Channel<ImageBlob>()

    init {
        startObservingAccounts()
        //startLoadingAccount()

        viewModelScope.launch {

            val accumulatedAccounts = accountChannel
                .consumeAsFlow()
                .onEach { account -> loadImage(account) }
                .scan(emptyList<Account>()) { list, value -> list + value }

            val accumulatedImages = imageChannel
                .consumeAsFlow()
                .scan(emptyList<ImageBlob>()) { list, value -> list + value }

            accumulatedAccounts.combine(accumulatedImages) { accounts, images ->
                accounts.associateWith { account ->
                    images.firstOrNull { it.id == account.id }
                }
            }.collect { result ->
                state.postValue(
                    result.map { (account, image) ->
                        ChooseProfileView.ProfileView(
                            id = account.id,
                            name = account.name,
                            image = image?.blob
                        )
                    }
                )
            }
        }

    }
}

1.4.0-RC

async(Dispatchers.Default)

runBlocking

flow

@Test
    fun coroutineTest() {
        runBlocking {
            flowOf("any").map {
                val result = ioFunction() //crash java.lang.ClassCastException: kotlin.coroutines.intrinsics.CoroutineSingletons cannot be cast to java.util.Map
                result
            }.collect { result ->
                Log.v("$result")
            }
        }
    }

    suspend fun ioFunction(): Map<Long, Int> = withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
        mapOf(1L to 4)
    }

Dispatchers.Main.immediate

Dispatchers.Main.immediate

launchAndForget

suspended fun foo(){
    operationA()  // <--- don't wait for it, it's on IO
    operationB() // <--- post on Main immediately
}

operationB() // <--- post on Main immediately
    operationA()  // <--- don't wait for it, it's on IO

runBlocking {
            launch (Dispatchers.Unconfined) {
                // check every x seconds if file exists, if it does then kill app (and all other coroutines)
            }
            launch (<http://Dispatchers.IO|Dispatchers.IO>) {
                // every x seconds send metrics to server
            }
            for (i in 1..Runtime.getRuntime().availableProcessors()) {
                launch (Dispatchers.Default) {
                    // use remaining cpu/mem resources to process batch items
                }
            }
        }

myFlow
.flatMapMerge { item ->
    flow { emit(suspendingFunctionThatMakesNetworkCall(item)) }
}

Note that even though this operator looks very familiar, we discourage its usage in a regular application-specific flows.
Most likely, suspending operation in [map] operator will be sufficient and linear transformations are much easier to reason about.

fun main() = runBlocking {

fun main() = runBlocking(Dispatchers.Default) {

GlobalScope.launch(Dispatchers.Unconfined)

GlobalScope.launch(start = CoroutineStart.UNDISPATCHED, context = Dispatchers.Unconfined)

GlobalScope.launch(Dispatchers.Unconfined)

GlobalScope.launch { }

LiveData<List<User>>

Map<User,Appointment>

flow

Flow

Deferred<R>

launch(customDispatcher)