launch나 async를 사용해 새로운 코루틴을 만들면 이 새로운 코루틴은 자동으로 해당 코루틴의 자식이 된다.fun main() {\n runBlocking {\n launch {\n delay(1.seconds)\n launch {\n delay(250.milliseconds)\n log("Grandchild done")\n }\n log("Child 1 done!")\n }\n launch {\n delay(500.milliseconds)\n log("Child 2 done!")\n }\n log("Parent done!")\n }\n}\n 0 [main @coroutine#1] Parent done!\n524 [main @coroutine#3] Child 2 done!\n1020 [main @coroutine#2] Child 1 done!\n1275 [main @coroutine#4] Grandchild done\n CoroutineScope를 생성한다.CoroutineScope 함수의 전형적인 사용 사례는 동시적 작업 분해(여러 코루틴을 활용해 계산 수행)suspend fun generateValue(): Int {\n delay(500.milliseconds)\n return Random.nextInt(0, 10)\n}\n\nsuspend fun computeSum() {\n log("Computing a sum...")\n val sum = coroutineScope {\n val a = async { generateValue() }\n val b = async { generateValue() }\n a.await() + b.await()\n }\n log("Sum is $sum")\n}\n coroutineScope 함수가 작업을 분해하는 데 사용되는 반면 구체적 생명주기를 정의하고, 동시 처리나 코루틴의 시작과 종료를 관리하는 클래스를 만들고 싶을 대도 잇다.class ComponentWithScope(dispatcher: CoroutineDispatcher = Dispatchers.Default) {\n private val scope = CoroutineScope(dispatcher + SupervisorJob())\n\n fun start() {\n log("Starting")\n scope.launch {\n while (true) {\n delay(500.milliseconds)\n log("Component working!")\n }\n }\n scope.launch {\n log("Doing a one-off task...")\n delay(500.milliseconds)\n log("Task done!")\n }\n }\n\n fun stop() {\n log("Stopping!")\n scope.cancel()\n }\n}\n Component 클래스의 인스턴스를 생성하고 start를 호출하면 컴포넌트 내부에서 코루틴이 시작된다.fun main() = runBlocking {\n GlobalScope.launch {\n delay(1000)\n launch {\n delay(250)\n log("Grandchild done")\n }\n log("Child 1 done!")\n }\n\n GlobalScope.launch {\n delay(500)\n log("Child 2 done!")\n }\n log("Parent done!")\n}\n 0 [main @coroutine#1] Parent done!\n GlobalScope는 전역 수준에 존재하는 스코프GlobalScope를 사용하면 구조화된 동시성이 제공하는 모든 이점을 포기fun main() {\n runBlocking(Dispatchers.Default) {\n log(coroutineContext)\n launch {\n log(coroutineContext)\n launch(Dispatchers.IO + CoroutineName("mine")) {\n log(coroutineContext)\n }\n }\n }\n}\n 0 [DefaultDispatcher-worker-1 @coroutine#1] [CoroutineId(1), "coroutine#1":BlockingCoroutine{Active}@3a617b0f, Dispatchers.Default]\n13 [DefaultDispatcher-worker-2 @coroutine#2] [CoroutineId(2), "coroutine#2":StandaloneCoroutine{Active}@5e2dba97, Dispatchers.Default]\n14 [DefaultDispatcher-worker-3 @mine#3] [CoroutineName(mine), CoroutineId(3), "mine#3":StandaloneCoroutine{Active}@12764f6a, Dispatchers.IO]\n fun main() = runBlocking(CoroutineName("A")) {\n log("A's job: ${coroutineContext.job}")\n launch(CoroutineName("B")) {\n log("B's job: ${coroutineContext.job}")\n log("B's parent: ${coroutineContext.job.parent}")\n }\n log("A's children: ${coroutineContext.job.children.toList()}")\n}\n fun main() = runBlocking {\n val launchedJob = launch {\n log("I'm launched!")\n delay(1000.milliseconds)\n log("I'm done!")\n }\n val asyncDeferred = async {\n log("I'm async")\n delay(1000.milliseconds)\n log("I'm done!")\n }\n delay(200.milliseconds)\n launchedJob.cancel()\n asyncDeferred.cancel()\n}\n 0 [main @coroutine#2] I'm launched!\n11 [main @coroutine#3] I'm async\n cancel을 호출해 해당 코루틴의 취소를 촉발할 수 있다.suspend fun calculateSomething(): Int {\n delay(3.seconds)\n return 2 + 2\n}\n\nfun main() = runBlocking {\n val quickResult = withTimeoutOrNull(500.milliseconds) {\n calculateSomething()\n }\n println(quickResult) // null\n val slowResult = withTimeoutOrNull(5.seconds) {\n calculateSomething()\n }\n println(slowResult) // 4\n}\n withTimeout, withTimeoutOrNull 함수는 계산에 쓸 최대 시간을 제한하면서 값을 계산할 수 있게 해준다.fun main() = runBlocking {\n val job = launch {\n launch {\n launch {\n launch {\n log("I'm started")\n delay(500.milliseconds)\n log("I'm done!")\n }\n }\n }\n }\n delay(200.milliseconds)\n job.cancel()\n}\n CancellationException이라는 특수한 예외를 특별한 지점에서 던지는 방식으로 작동CancellationException을 던진다.suspend fun doCpuHeavyWork(): Int {\n log("I'm doing work!")\n var counter = 0\n val startTime = System.currentTimeMillis()\n while (System.currentTimeMillis() < startTime + 500) {\n counter++\n }\n return counter\n}\n\nfun main() = runBlocking {\n val myJob = launch {\n repeat(5) {\n doCpuHeavyWork()\n }\n }\n delay(600.milliseconds)\n myJob.cancel()\n}\n doCpuHeavyWork가 5번 완료된다.doCpuHeavyWork 함수는 일시 중단 지점을 포함하지 않는다.delay 호출을 추가하면 됨.val myJob = launch {\n repeat(5) {\n doCpuHeavyWork()\n if (!isActive) return@launch\n }\n}\n isActive 속성을 확인\nfalse이면 비활성화ensureActive 함수는 비활성화일 때, CancellationException을 던진다.yield 함수 제공\nfun doCpuHeavyWork(): Int {\n var counter = 0\n val startTime = System.currentTimeMillis()\n while (System.currentTimeMillis() < startTime + 500) {\n counter++\n }\n return counter\n}\n\nfun main() {\n runBlocking {\n launch {\n repeat(3) {\n doCpuHeavyWork()\n }\n }\n launch {\n repeat(3) {\n doCpuHeavyWork()\n }\n }\n }\n}\n suspend fun doCpuHeavyWork(): Int {\n var counter = 0\n val startTime = System.currentTimeMillis()\n while (System.currentTimeMillis() < startTime + 500) {\n counter++\n yield()\n }\n return counter\n}\n\nfun main() {\n runBlocking {\n launch {\n repeat(3) {\n doCpuHeavyWork()\n }\n }\n launch {\n repeat(3) {\n doCpuHeavyWork()\n }\n }\n }\n}\n yield 함수를 사용하면 코루틴이 교차 실행됨close 함수가 호출되지 않고 리소스가 누수될 수 있음.finally 블록을 사용해 명시적으로 닫자.AutoClosable 인터페이스를 구현하는 경우 .use 함수를 사용해 같은 동작을 더 간결하게 처리할 수 있다.fun main() {\n val names = flow {\n emit("Jo")\n emit("May")\n emit("Sue")\n }\n val uppercasedNames = names.map {\n it.uppercase()\n }\n runBlocking {\n uppercasedNames.collect { println("$it ") }\n }\n}\n map 함수는 업스트림 플로우를 받아 원소를 변환한 후 다운스트림 플로우에 원소를 배출 할 수 있다.fun main() {\n val names = flow {\n emit("Jo")\n emit("May")\n emit("Sue")\n }\n val upperAndLowercasedNames = names.transform {\n emit(it.uppercase())\n emit(it.lowercase())\n }\n runBlocking {\n upperAndLowercasedNames.collect { println("$it ") }\n }\n}\n transform 함수 사용flowOf 함수로 줄임표현 사용 가능takeWhile 같은 함수들을 플로우에서도 똑같이 쓸 수 있다.fun main() {\n val temps = getTemperatures()\n temps\n .take(5)\n .collect {\n log(it)\n }\n}\n take 함수는 수집자와 관련된 코루틴 스코프를 취소하는 방식 외에 플로우 수집을 제어된 방식으로 취소하는 또 다른 방법fun main() {\n val temps = getTemperatures()\n temps\n .take(5)\n .onCompletion { cause ->\n if (cause != null) {\n println("An error occurred! $cause")\n } else {\n println("Completed!")\n }\n }\n .collect {\n println(it)\n }\n}\n onCompletion 연산자를 사용할 수 있다.\nfun main() {\n flow\n .onEmpty {\n println("Nothing - emitting default value!")\n emit(0)\n }\n .onStart {\n println("Starting")\n }\n .onEach {\n println("On $it")\n }\n .onCompletion {\n println("Done!")\n }\n .collect()\n}\n onCompletion은 플로우 생명주기의 특정 단계에서 작업을 수행할 수 있는 중간 연산자onStart는 플로우의 수집이 시작될 때 첫 번째 배출이 일어나기 전에 실행onEach는 업스트림 플로우에서 배출된 각 원소에 대해 작업을 수행한 후 다운스트림 플로우에 전달onEmpty는 로직을 추가로 수행하거나 기본값을 제공fun getAllUserIds(): Flow<Int> {\n return flow {\n repeat(3) {\n delay(200.milliseconds)\n log("Emitting!")\n emit(it)\n }\n }\n}\n\nsuspend fun getProfileFromNetwork(id: Int): String {\n delay(2.seconds)\n return "Profile[$id]"\n}\n\nfun main() {\n val ids = getAllUserIds()\n runBlocking {\n ids\n .map { getProfileFromNetwork(it) }\n .collect { log("Got $it") }\n }\n}\n 0 [main @coroutine#1] Emitting!\n2028 [main @coroutine#1] Got Profile[0]\n2234 [main @coroutine#1] Emitting!\n4240 [main @coroutine#1] Got Profile[1]\n4447 [main @coroutine#1] Emitting!\n6453 [main @coroutine#1] Got Profile[2]\n fun main() {\n val ids = getAllUserIds()\n runBlocking {\n ids\n .buffer(3)\n .map { getProfileFromNetwork(it) }\n .collect { log("Got $it") }\n }\n}\n 0 [main @coroutine#2] Emitting!\n213 [main @coroutine#2] Emitting!\n414 [main @coroutine#2] Emitting!\n2030 [main @coroutine#1] Got Profile[0]\n4040 [main @coroutine#1] Got Profile[1]\n6046 [main @coroutine#1] Got Profile[2]\n buffer 연산자는 버퍼를 추가해서 다운스트림 플로우가 이미 배출된 원소를 처리하느라 바쁜 동안에도 업스트림 플로우가 원소를 배출할 수 있게 해준다.onBufferOverflow 파라미터를 통해 버퍼 용량이 초과될 때 어떤 일이 발생할지 지정할 수 있다.\nfun main() {\n runBlocking {\n val temps = getTemperatures()\n temps\n .onEach {\n log("Read $it from sensor")\n }\n .conflate()\n .collect { \n log("Collected $it")\n delay(1.seconds)\n }\n }\n}\n 142709 [main @coroutine#1] Collected 6\n142864 [main @coroutine#2] Read 28 from sensor\n143370 [main @coroutine#2] Read 24 from sensor\n143711 [main @coroutine#1] Collected 24\n143876 [main @coroutine#2] Read -2 from sensor\n144382 [main @coroutine#2] Read 1 from sensor\n144715 [main @coroutine#1] Collected 1\n144888 [main @coroutine#2] Read 1 from sensor\n145391 [main @coroutine#2] Read 29 from sensor\n145719 [main @coroutine#1] Collected 29\n145893 [main @coroutine#2] Read 9 from sensor\n146396 [main @coroutine#2] Read 1 from sensor\n146725 [main @coroutine#1] Collected 1\n conflate를 쓰면 업스트림 플로우의 실행을 다운스트림 연산자의 실행과 분리할 수 있다.val searchQuery = flow {\n emit("K")\n delay(100.milliseconds)\n emit("Ko")\n delay(200.milliseconds)\n emit("Kotl")\n delay(500.milliseconds)\n emit("Kotlin")\n}\n fun main() = runBlocking {\n searchQuery\n .debounce(250.milliseconds)\n .collect {\n log("Searching for $it")\n }\n}\n 0 [main @coroutine#1] Searching for Kotl\n247 [main @coroutine#1] Searching for Kotlin\n debounce 연산자는 업스트림에서 원소가 배출되지 않은 상태로 정해진 타임아웃 시간이 지나야만 항목을 다운스트림 플로우로 배출fun main() {\n runBlocking {\n flowOf(1)\n .onEach { log("A") }\n .flowOn(Dispatchers.Default)\n .onEach { log("B") }\n .flowOn(Dispatchers.IO)\n .onEach { log("C") }\n .collect()\n }\n}\n 0 [DefaultDispatcher-worker-3 @coroutine#3] A\n24 [DefaultDispatcher-worker-1 @coroutine#2] B\n26 [main @coroutine#1] C\n flowOn 연산자는 처리 파이프라인의 일부를 다른 디스패처나 다른 코루틴 콘텍스트에서 힐행할 수 있다.\nflowOn 연산자는 업스트림 플로우의 디스패처에만 영향을 미친다.fun Flow<Double>.averageOfLast(n: Int): Flow<Double> =\n flow {\n val numbers = mutableListOf<Double>()\n collect { \n if (numbers.size > n) {\n numbers.removeFirst()\n }\n numbers.add(it)\n emit(numbers.average())\n }\n }\n\nfun main() = runBlocking {\n flowOf(1.0, 2.0, 30.0, 121.0)\n .averageOfLast(3)\n .collect {\n print("$it ")\n }\n}\n fun main() = runBlocking {\n getTemperatures()\n .onEach { \n log(it)\n }\n .collect()\n}\n collect는 플로우의 각 원소에 대해 실행할 람다를 지정할 수 있는 유용한 지름길을 제공fun main() = runBlocking {\n getTemperatures()\n .first()\n}\n first나 firstOrNull 같은 최종연산자는 원소를 받은 다음에 업스트림 플로우를 취소할 수 있다.@Composable fun TemperatureDisplay(temps: Flow<Int>) {\n val temperature = temps.collectAsState(null)\n Box {\n temperature.value?.let {\n Text("The current temperature is $it!")\n }\n }\n}\n suspend fun createValues(): List<Int> {\n return buildList {\n add(1)\n delay(1.seconds)\n add(2)\n delay(1.seconds)\n add(3)\n delay(1.seconds)\n }\n}\n\nfun main() = runBlocking {\n val list = createValues()\n list.forEach {\n log(it)\n }\n}\n fun createValues(): Flow<Int> {\n return flow {\n emit(1)\n delay(1.seconds)\n emit(2)\n delay(1.seconds)\n emit(3)\n delay(1.seconds)\n }\n}\n\nfun main() = runBlocking {\n val myFlowOfValues = createValues()\n myFlowOfValues.collect { log(it) }\n}\n 0 [main @coroutine#1] 1\n1036 [main @coroutine#1] 2\n2042 [main @coroutine#1] 3\n fun main() = runBlocking {\n val letters = flow {\n log("Emitting A!")\n emit("A")\n delay(200.milliseconds)\n log("Emitting B!")\n emit("B")\n }\n}\n flow 빌더 함수를 호출해도 실제 작업이 시작되지 않음.val counterFlow = flow {\n var x = 0\n while (true) {\n emit(x++)\n delay(200.milliseconds)\n }\n}\n Flow에 대해 collect 함수를 호출하면 그 로직이 실행된다collect는 일시 중단 함수이며, 플로우가 끝날 때까지 일시 중단된다.val letters = flow {\n log("Emitting A!")\n emit("A")\n delay(200.milliseconds)\n log("Emitting B!")\n emit("B")\n}\n\nfun main() = runBlocking {\n letters.collect {\n log("Collecting: $it")\n delay(500.milliseconds)\n }\n}\n 0 [main @coroutine#1] Emitting A!\n15 [main @coroutine#1] Collecting: A\n737 [main @coroutine#1] Emitting B!\n737 [main @coroutine#1] Collecting: B\n fun main() = runBlocking {\n letters.collect {\n log("(1) Collecting: $it")\n delay(500.milliseconds)\n }\n letters.collect {\n log("(2) Collecting: $it")\n delay(500.milliseconds)\n }\n}\n 0 [main @coroutine#1] Emitting A!\n16 [main @coroutine#1] (1) Collecting: A\n743 [main @coroutine#1] Emitting B!\n743 [main @coroutine#1] (1) Collecting: B\n1247 [main @coroutine#1] Emitting A!\n1247 [main @coroutine#1] (2) Collecting: A\n1958 [main @coroutine#1] Emitting B!\n1958 [main @coroutine#1] (2) Collecting: B\n fun main() = runBlocking {\n val collector = launch {\n counterFlow.collect {\n println(it)\n }\n }\n delay(5.seconds)\n collector.cancel()\n}\n Flow와 FlowCollector라는 2가지 인터페이스만 필요collect를 호출하면 플로우 빌더 함수의 본문이 실행emit을 호출하면 emit에 전달된 파라미터로 collect에 전달된 람다가 호출suspend fun getRandomNumber(): Int {\n delay(500.milliseconds)\n return Random.nextInt()\n}\n\nval randomNumbers = flow {\n repeat(10) {\n emit(getRandomNumber())\n }\n}\n\nfun main() = runBlocking {\n randomNumbers.collect {\n log(it)\n }\n}\n 0 [main @coroutine#1] -1441864547\n513 [main @coroutine#1] 1101626017\n1020 [main @coroutine#1] 313359960\n1527 [main @coroutine#1] -2002910241\n2033 [main @coroutine#1] 890150628\n2538 [main @coroutine#1] -1433970862\n3045 [main @coroutine#1] 1503636281\n3548 [main @coroutine#1] -1528949568\n4055 [main @coroutine#1] -1562012272\n4561 [main @coroutine#1] 2076525050\n val randomNumbers = channelFlow {\n repeat(10) {\n launch {\n send(getRandomNumber())\n }\n }\n}\n channelFlowclass RadioStation {\n private val _messageFlow = MutableSharedFlow<Int>()\n val messageFlow = _messageFlow.asSharedFlow()\n\n fun beginBroadcasting(scope: CoroutineScope) {\n scope.launch {\n while (true) {\n delay(500.milliseconds)\n val number = Random.nextInt(0..10)\n log("Emitting $number!")\n _messageFlow.emit(number)\n }\n }\n }\n}\n fun main() = runBlocking {\n RadioStation().beginBroadcasting(this)\n}\n fun main() = runBlocking {\n val radioStation = RadioStation()\n radioStation.beginBroadcasting(this)\n delay(600.milliseconds)\n radioStation.messageFlow.collect {\n log("A collecting: $it!")\n }\n}\n private val _messageFlow = MutableSharedFlow<Int>(replay = 5)\n replay 파라미터 설정fun querySensor(): Int = Random.nextInt(-10..30)\n\nfun getTemperatures(): Flow<Int> {\n return flow {\n while (true) {\n emit(querySensor())\n delay(500.milliseconds)\n }\n }\n}\n fun celsiusToFahrenheit(celsius: Int) = celsius * 9.0 / 5.0 + 32.0\n\nfun main() {\n val temps = getTemperatures()\n runBlocking {\n launch {\n temps.collect {\n log("$it Celsius")\n }\n }\n launch {\n temps.collect {\n log("${celsiusToFahrenheit(it)} Fahrenheit")\n }\n }\n }\n}\n fun main() {\n val temps = getTemperatures()\n runBlocking {\n val sharedTemps = temps.shareIn(this, SharingStarted.Lazily)\n launch {\n sharedTemps.collect {\n log("$it Celsius")\n }\n }\n launch {\n sharedTemps.collect {\n log("${celsiusToFahrenheit(it)} Fahrenheit")\n }\n }\n }\n}\n shareIn 함수를 사용하면 주어진 콜드 플로우를 한 플로우인 공유 플로우로 변환할 수 있다.started는 플로우가 실제로 언제 시작돼야 하는지를 정의\nEagerly는 플로우 수집을 즉시 시작Lazily는 첫 번째 구독자가 나타나야만 수집 시작WhileSubscribed는 첫 번째 구독자가 나타나야 수집을 시작하고, 마지막 구독자가 사라지면 플로우 수집을 취소class ViewCounter {\n private val _counter = MutableStateFlow(0)\n val counter = _counter.asStateFlow()\n fun increment() {\n _counter.update { it + 1 }\n }\n}\n\nfun main() {\n val vc = ViewCounter()\n vc.increment()\n println(vc.counter.value)\n}\n emit을 사용하는 대신, 값을 갱신하는 update 함수 사용 fun increment() {\n _counter.value++\n}\n value 는 가변 속성이니까 위와 같이 구현해도 될까?enum class Direction { LEFT, RIGHT }\n\nclass DirectionSelector {\n private val _direction = MutableStateFlow(Direction.LEFT)\n val direction = _direction.asStateFlow()\n\n fun turn(d: Direction) {\n _direction.update { d }\n }\n}\n\nfun main() = runBlocking {\n val switch = DirectionSelector()\n launch {\n switch.direction.collect {\n log("Direction now $it")\n }\n }\n delay(200.milliseconds)\n switch.turn(Direction.RIGHT)\n delay(200.milliseconds)\n switch.turn(Direction.LEFT)\n delay(200.milliseconds)\n switch.turn(Direction.LEFT)\n}\n 0 [main @coroutine#2] Direction now LEFT\n210 [main @coroutine#2] Direction now RIGHT\n405 [main @coroutine#2] Direction now LEFT\n fun main() = runBlocking {\n val temps = getTemperatures()\n\n runBlocking {\n val tempState = temps.stateIn(this)\n println(tempState.value)\n delay(800.milliseconds)\n println(tempState.value)\n }\n}\n stateIn으로 콜드 플로우를 상태 플로우로 변환할 수 있다.class Broadcaster {\n private val _messages = MutableSharedFlow<String>()\n val messages = _messages.asSharedFlow()\n fun beginBroadcasting(scope: CoroutineScope) {\n scope.launch {\n _messages.emit("Hello!")\n _messages.emit("Hi!")\n _messages.emit("Hola!")\n }\n }\n}\n\nfun main(): Unit = runBlocking {\n val broadcaster = Broadcaster()\n broadcaster.beginBroadcasting(this)\n delay(200.milliseconds)\n broadcaster.messages.collect {\n println("Message: $it")\n }\n}\n class Broadcaster {\n private val _messages = MutableStateFlow<List<String>>(emptyList())\n val messages = _messages.asStateFlow()\n fun beginBroadcasting(scope: CoroutineScope) {\n scope.launch {\n _messages.update { it + "Hello!" }\n _messages.update { it + "Hi!" }\n _messages.update { it + "Hola!" }\n }\n }\n}\n\nfun main() = runBlocking {\n val broadcaster = Broadcaster()\n broadcaster.beginBroadcasting(this)\n delay(200.milliseconds)\n println(broadcaster.messages.value)\n}\n | 콜드 플로우 | \n핫 플로우 | \n
|---|---|
| 기본적으로 비활성(수집자에 의해 활성화됨) | \n기본적으로 활성화됨 | \n
| 수집자가 하나 있음 | \n여러 구독자가 있음 | \n
| 수집자는 모든 배출을 받음 | \n구독자는 구독 시작 시점부터 배출을 받음 | \n
| 보통은 완료됨 | \n완료되지 않음 | \n
| 하나의 코루틴에서 배출 발생(channelFlow 사용 시 예외) | \n여러 코루틴에서 배출할 수 있음 | \n