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
fun main(): Unit = runBlocking {\n try {\n launch {\n throw UnsupportedOperationException("Ouch!")\n }\n } catch (u: UnsupportedOperationException) {\n println("Handled $u")\n }\n}\n fun main(): Unit = runBlocking {\n launch {\n try {\n throw UnsupportedOperationException("Ouch!")\n } catch (u: UnsupportedOperationException) {\n println("Handled $u")\n }\n }\n}\n launch에 전달되는 람다 블록안에서는 잡힌다.fun main(): Unit = runBlocking {\n val myDeferredInt: Deferred<Int> = async {\n throw UnsupportedOperationException("Ouch!")\n }\n try {\n val i: Int = myDeferredInt.await()\n println(i)\n } catch (u: UnsupportedOperationException) {\n println("Handled: $u")\n }\n}\n await를 감싼 try-catch에서 예외를 잡지만 동시에 예외를 출력한다.fun main(): Unit = runBlocking {\n launch {\n try {\n while (true) {\n println("Heartbeat!")\n delay(500.milliseconds)\n }\n } catch (e: Exception) {\n println("Heartbeat terminated: $e")\n throw e\n }\n }\n launch {\n delay(1.seconds)\n throw UnsupportedOperationException("Ow!")\n }\n}\n Heartbeat!\nHeartbeat!\nHeartbeat terminated: kotlinx.coroutines.JobCancellationException: Parent job is Cancelling; job="coroutine#1":BlockingCoroutine{Cancelling}@130f889\nException in thread "main" java.lang.UnsupportedOperationException: Ow!\n fun main(): Unit = runBlocking {\n launch {\n try {\n while (true) {\n println("Heartbeat!")\n delay(500.milliseconds)\n }\n } catch (e: Exception) {\n println("Heartbeat terminated: $e")\n throw e\n }\n }\n launch {\n try {\n delay(1.seconds)\n throw UnsupportedOperationException("Ow!")\n } catch (u: UnsupportedOperationException) {\n println("Caught $u")\n }\n }\n}\n fun main(): Unit = runBlocking {\n supervisorScope {\n launch {\n try {\n while (true) {\n println("Heartbeat!")\n delay(500.milliseconds)\n }\n } catch (e: Exception) {\n println("Heartbeat terminated: $e")\n throw e\n }\n }\n launch {\n delay(1.seconds)\n throw UnsupportedOperationException("Ow!")\n }\n }\n}\n CoroutineExceptionHandler라는 특별한 핸들러에게 전달된다.CoroutineExceptionHandler를 코루틴 콘텍스트에 제공하면 처리되지 않은 예외를 처리하는 동작을 커스텀화할 수 있다.fun main(): Unit = runBlocking {\n val supervisor = ComponentWithScope()\n supervisor.action()\n delay(1.seconds)\n}\n\nclass ComponentWithScope(dispatcher: CoroutineDispatcher = Dispatchers.Default) {\n private val exceptionHandler = CoroutineExceptionHandler { _, e ->\n println("[ERROR] ${e.message}")\n }\n private val scope = CoroutineScope(\n SupervisorJob() + dispatcher + exceptionHandler\n )\n\n fun action() = scope.launch {\n throw UnsupportedOperationException("Ouch!")\n }\n}\n private val topLevelHandler = CoroutineExceptionHandler { _, e ->\n println("[TOP] ${e.message}")\n}\n\nprivate val intermediateHandler = CoroutineExceptionHandler { _, e ->\n println("[INTERMEDIATE] ${e.message}")\n}\n\n@OptIn(DelicateCoroutinesApi::class)\nfun main() {\n GlobalScope.launch(topLevelHandler) {\n launch(intermediateHandler) {\n throw UnsupportedOperationException("Ouch!")\n }\n }\n Thread.sleep(1000)\n}\n class ComponentWithScope(dispatcher: CoroutineDispatcher = Dispatchers.Default) {\n private val exceptionHandler = CoroutineExceptionHandler { _, e ->\n println("[ERROR] ${e.message}")\n }\n private val scope = CoroutineScope(\n SupervisorJob() + dispatcher + exceptionHandler\n )\n\n fun action() = scope.launch {\n async {\n throw UnsupportedOperationException("Ouch!")\n }\n }\n}\n\nfun main() {\n val supervisor = ComponentWithScope()\n supervisor.action()\n delay(1.seconds)\n}\n async로 시작되면 이 예외를 처리하는 책임은 await()를 호출하는 Deferred 소비자에게 있다.class UnhappyFlowException : Exception()\n\nval exceptionalFlow = flow {\n repeat(5) { number ->\n emit(number)\n }\n throw UnhappyFlowException()\n}\n collect에서 예외가 던져진다.fun main() = runBlocking {\n exceptionalFlow\n .catch { cause ->\n println("\\nHandled: $cause")\n emit(-1)\n }\n .collect {\n println("$it ")\n }\n}\n catch는 플로우에서 발생한 예외를 처리할 수 있는 중간 연산자fun main() = runBlocking {\n exceptionalFlow\n .map { \n it + 1\n }\n .catch { cause ->\n println("\\nHandled: $cause")\n }\n .onEach { \n throw UnhappyFlowException()\n }\n .collect()\n}\n catch는 업스트림에 대해서만 작동하며, 플로우 처리 파이프라인의 앞쪽에서 발생한 예외들만 잡아낸다.val unreliableFlow = flow {\n println("Starting the flow!")\n repeat(10) { number ->\n if (Random.nextDouble() < 0.1) throw CommunicationException()\n emit(number)\n }\n}\n\nfun main() = runBlocking {\n unreliableFlow\n .retry(5) { cause ->\n println("\\nHandled: $cause")\n cause is CommunicationException\n }\n .collect { number ->\n println("$number")\n }\n}\n retry 연산자는 업스트림의 예외를 잡는다.class PlaygroundTest {\n\n @Test\n fun testDelay() = runTest {\n val startTime = System.currentTimeMillis()\n delay(20.seconds)\n println(System.currentTimeMillis() - startTime)\n }\n}\n runTest는 속도를 높이기 위해 특별한 테스트 디스패처와 스케줄러를 사용runTest의 디스패처는 단일 스레드@OptIn(ExperimentalCoroutinesApi::class)\n@Test\nfun testDelay() = runTest {\n var x = 0\n launch {\n delay(500.milliseconds)\n x++\n }\n launch {\n delay(1.seconds)\n x++\n }\n println(currentTime)\n\n delay(600.milliseconds)\n assertEquals(1, x)\n println(currentTime)\n\n delay(500.milliseconds)\n assertEquals(2, x)\n println(currentTime)\n}\n delay를 통해 가상 시계 진행@OptIn(ExperimentalCoroutinesApi::class)\n@Test\nfun testDelay() = runTest {\n var x = 0\n launch { \n x++\n launch { \n x++\n }\n }\n launch { \n delay(200.milliseconds)\n x++\n }\n runCurrent()\n assertEquals(2, x)\n advanceUntilIdle()\n assertEquals(3, x)\n}\n advanceUntilIdle 함수를 사용할 수 있다.val myFlow = flow { \n emit(1)\n emit(2)\n emit(3)\n}\n\n@Test\nfun doTest() = runTest { \n val results = myFlow.toList()\n assertEquals(3, results.size)\n}\n @Test\nfun doTest() = runTest { \n val results = myFlow.test {\n assertEquals(1, awaitItem())\n assertEquals(2, awaitItem())\n assertEquals(3, awaitItem())\n awaitComplete()\n }\n}\n 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