native-mt-#

val foo = runCatching { bar() }.getOrNull()  // or similar try-catch block

suspend fun jobLifecycle () = coroutineScope {
   val job =  launch{
       println("Working....")
       delay(2000L)
       println("Done !")
    }

    delay(1000L)
    job.cancel() 
    // delay(1L) i have to do it to print correct value of job.isCompleted below

    println("isCompleted: ${job.isCompleted}") // it is printing "false" but if i delay for some time after cancelling the job it prints  "true".

}

MutableSharedFlow

SharedFlow

onSubscription

private val counter = AtomicInteger()

class Example {

    private val scope = CoroutineScope(Job())

    private val _incoming = MutableSharedFlow<Int>(replay = 0)
    private val incoming: SharedFlow<String> = _incoming
        .onSubscription { emit(-1) }
        .map {
            // Emulate expensive operator that we want to "share".
            delay(500L)
            it.toString()
        }
        .shareIn(scope, replay = 0)

    suspend fun request(): String =
        incoming
            .onSubscription { _incoming.emit(counter.incrementAndGet()) }
            .first()
}

fun main() {
    val example = Example()
    repeat(10) {
        val result = runBlocking { example.request() }
        println(result)
    }
}

-1
2
3
4
5
6
7
8
9
10

1

-1

suspend fun getThree() = 
  withContext(IO) {
    val one = async { getOne() }
    val two = async { getTwo() }
    
    one.await() + two.await()
  }

coroutineScope

withContext

val workers = ArrayList<Future<*>>(10)
try {
    for (i in 1..10) {
        val task = getTask() ?: break
        workers += taskExecutor.submit {
            workerLoop(task) // some computation
        }
    }
} catch (t: Throwable) {
    // log error
}

workers.forEach {
    try {
        it.get()
    } catch (t: Throwable) {
        // log error
    }
}

val workers = ArrayList<Deferred<*>>(10)
try {
    for (i in 1..10) {
        val task = getTask() ?: break
        workers += taskExecutor.async {
            workerLoop(task) // some computation
        }
    }
} catch (t: Throwable) {
    // Log error
}

runBlocking {
    workers.forEach {
        try {
            it.await()
        } catch (t: Throwable) {
            // Log error
        }
    }
}

liveData

val users = liveData {
    emit(getUsers(count=20))
}

val users by lazy {
    MutableStateFlow<List<User>>(listOf()).also { usersFlow ->
        viewModelScope.launch {
            usersFlow.value = getUsers(count = 20)
        }
    }
}

onCreate

DebugProbes.install()

java.lang.NoClassDefFoundError: Failed resolution of: Lcom/google/android/gms/common/R$string

DebugProbes.install()

CoroutineScope

SupervisorJob()

launch

coroutineContext

<http://Dispatchers.IO|Dispatchers.IO>

Executor.asCoroutineDispatcher

interface Foo {
    suspend fun test(i: Int)
  }

  @Test
  fun myTest() = testCoroutineDispatcher.runBlockingTest {
    val mutableState: MutableStateFlow<Int> = MutableStateFlow(1)

    val foo = mockk<Foo>()

    val job = launch {
      mutableState
        .filter { it != 1 }
        .collect {
          delay(100)
          foo.test(it)
        }
    }

    mutableState.value = 2

    // how to wait here to be able to verify?

    coVerify {
      foo.test(2)
    }
  }

<http://Dispatchers.IO|Dispatchers.IO>.asExecutor()

Dispatchers.Default

suspend

AtomicRef

Deferred

update()

updateAsync()

updateAsync()

update()

updateAsync()

shareIn

WhileSubscribed

shareIn

All methods of data flow are **thread-safe** and can be safely invoked from concurrent coroutines without
external synchronization.

List<Flow<T>>

Flow<List<T>>

List<T>

Flow<T>

combine()

actor

isActive

true

while

delay

withContext

fun main() = runBlocking<Unit> {
    withTimeout(200) {
        withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
            Thread.sleep(5000)
        }
    }
}