├── app
├── .gitignore
├── src
│ ├── main
│ │ ├── res
│ │ │ ├── values
│ │ │ │ ├── strings.xml
│ │ │ │ ├── themes.xml
│ │ │ │ └── colors.xml
│ │ │ ├── mipmap-hdpi
│ │ │ │ ├── ic_launcher.webp
│ │ │ │ └── ic_launcher_round.webp
│ │ │ ├── mipmap-mdpi
│ │ │ │ ├── ic_launcher.webp
│ │ │ │ └── ic_launcher_round.webp
│ │ │ ├── mipmap-xhdpi
│ │ │ │ ├── ic_launcher.webp
│ │ │ │ └── ic_launcher_round.webp
│ │ │ ├── mipmap-xxhdpi
│ │ │ │ ├── ic_launcher.webp
│ │ │ │ └── ic_launcher_round.webp
│ │ │ ├── mipmap-xxxhdpi
│ │ │ │ ├── ic_launcher.webp
│ │ │ │ └── ic_launcher_round.webp
│ │ │ ├── layout
│ │ │ │ ├── layout_1.xml
│ │ │ │ └── layout_2.xml
│ │ │ ├── mipmap-anydpi-v26
│ │ │ │ ├── ic_launcher.xml
│ │ │ │ └── ic_launcher_round.xml
│ │ │ ├── xml
│ │ │ │ ├── backup_rules.xml
│ │ │ │ └── data_extraction_rules.xml
│ │ │ └── drawable
│ │ │ │ ├── ic_launcher_foreground.xml
│ │ │ │ └── ic_launcher_background.xml
│ │ ├── java
│ │ │ └── com
│ │ │ │ └── rengwuxian
│ │ │ │ └── coursecoroutines
│ │ │ │ ├── _4_flow
│ │ │ │ ├── 1_overview.kt
│ │ │ │ ├── 20_chunked.kt
│ │ │ │ ├── 17_withIndex.kt
│ │ │ │ ├── 5_actor.kt
│ │ │ │ ├── 19_onEach.kt
│ │ │ │ ├── 11_distinctUntilChanged.kt
│ │ │ │ ├── 2_produce.kt
│ │ │ │ ├── 14_drop_take.kt
│ │ │ │ ├── 32_StateFlow.kt
│ │ │ │ ├── 12_custom_flow.kt
│ │ │ │ ├── 30_shareIn.kt
│ │ │ │ ├── 6_flow.kt
│ │ │ │ ├── 9_collect.kt
│ │ │ │ ├── 24_onStart_onCompletion_onEmpty.kt
│ │ │ │ ├── 23_retry.kt
│ │ │ │ ├── 15_map.kt
│ │ │ │ ├── 7_flow_use_case.kt
│ │ │ │ ├── 10_filter.kt
│ │ │ │ ├── 3_channel.kt
│ │ │ │ ├── 26_buffer.kt
│ │ │ │ ├── 22_catch.kt
│ │ │ │ ├── 31_MutableSharedFlow.kt
│ │ │ │ ├── 16_transform.kt
│ │ │ │ ├── 13_timeout_sample_debounce.kt
│ │ │ │ ├── 21_try_catch.kt
│ │ │ │ ├── 28_convert.kt
│ │ │ │ ├── 18_reduce_fold.kt
│ │ │ │ ├── 4_channel_api.kt
│ │ │ │ ├── 25_flowOn.kt
│ │ │ │ ├── 29_SharedFlow.kt
│ │ │ │ ├── 27_merge.kt
│ │ │ │ └── 8_build.kt
│ │ │ │ ├── ui
│ │ │ │ └── theme
│ │ │ │ │ ├── Color.kt
│ │ │ │ │ ├── Type.kt
│ │ │ │ │ └── Theme.kt
│ │ │ │ ├── _1_basics
│ │ │ │ ├── 5_custom_suspend.kt
│ │ │ │ ├── 12_runBlocking.kt
│ │ │ │ ├── 7_de_magic.kt
│ │ │ │ ├── 3_android.kt
│ │ │ │ ├── 4_withContext.kt
│ │ │ │ ├── 6_withContext_2.kt
│ │ │ │ ├── 1_launch.kt
│ │ │ │ ├── 2_suspend.kt
│ │ │ │ ├── 10_parallel.kt
│ │ │ │ ├── 0_preview.kt
│ │ │ │ ├── 9_structured_concurrency.kt
│ │ │ │ └── 11_callback_to_suspend.kt
│ │ │ │ ├── _2_structured_concurrency
│ │ │ │ ├── 3_thread_stop.kt
│ │ │ │ ├── 9_CoroutineExceptionHandler.kt
│ │ │ │ ├── 6_structural_cancellation.kt
│ │ │ │ ├── 12_SupervisorJob.kt
│ │ │ │ ├── 11_async_exception.kt
│ │ │ │ ├── 1_whats_a_coroutine.kt
│ │ │ │ ├── 10_structured_exception.kt
│ │ │ │ ├── 2_parent_children.kt
│ │ │ │ ├── 4_thread_interrupt.kt
│ │ │ │ ├── 8_exception.kt
│ │ │ │ ├── 5_cancel.kt
│ │ │ │ └── 7_NonCancellable.kt
│ │ │ │ ├── _3_scope_context
│ │ │ │ ├── 5_withContext_again.kt
│ │ │ │ ├── 6_CoroutineName.kt
│ │ │ │ ├── 1_scope_context.kt
│ │ │ │ ├── 2_GlobalScope.kt
│ │ │ │ ├── 8_custom_CoroutineContext.kt
│ │ │ │ ├── 3_coroutineContext.kt
│ │ │ │ ├── 7_CoroutineContext.kt
│ │ │ │ └── 4_coroutineScope.kt
│ │ │ │ ├── _5_collaboration
│ │ │ │ ├── 4_ThreadLocal.kt
│ │ │ │ ├── 2_select.kt
│ │ │ │ ├── Java.java
│ │ │ │ ├── 3_mutex.kt
│ │ │ │ └── 1_collaboration.kt
│ │ │ │ ├── common
│ │ │ │ ├── Common.kt
│ │ │ │ └── Api.kt
│ │ │ │ └── MainActivity.kt
│ │ └── AndroidManifest.xml
│ ├── test
│ │ └── java
│ │ │ └── com
│ │ │ └── rengwuxian
│ │ │ └── coursecoroutines
│ │ │ └── ExampleUnitTest.kt
│ └── androidTest
│ │ └── java
│ │ └── com
│ │ └── rengwuxian
│ │ └── coursecoroutines
│ │ └── ExampleInstrumentedTest.kt
├── proguard-rules.pro
└── build.gradle.kts
├── images
└── course-cover.jpg
├── gradle
├── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
└── libs.versions.toml
├── .gitignore
├── README.md
├── settings.gradle.kts
├── gradle.properties
├── gradlew.bat
└── gradlew
/app/.gitignore:
--------------------------------------------------------------------------------
1 | /build
--------------------------------------------------------------------------------
/images/course-cover.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rengwuxian/CourseCoroutines/HEAD/images/course-cover.jpg
--------------------------------------------------------------------------------
/app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 | CourseCoroutines
3 |
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rengwuxian/CourseCoroutines/HEAD/gradle/wrapper/gradle-wrapper.jar
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rengwuxian/CourseCoroutines/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher.webp
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rengwuxian/CourseCoroutines/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher.webp
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rengwuxian/CourseCoroutines/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher.webp
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rengwuxian/CourseCoroutines/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rengwuxian/CourseCoroutines/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rengwuxian/CourseCoroutines/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rengwuxian/CourseCoroutines/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rengwuxian/CourseCoroutines/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.iml
2 | .gradle
3 | /local.properties
4 | /.idea
5 | .DS_Store
6 | /build
7 | /captures
8 | .externalNativeBuild
9 | .cxx
10 | local.properties
11 |
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rengwuxian/CourseCoroutines/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rengwuxian/CourseCoroutines/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # 《Kotlin 协程完全教程》配套源码
2 |
3 | 这是课程《Kotlin 协程完全教程 - 从基础实践到进阶再到专家》的配套源码。
4 |
5 | 课程地址：[rengwuxian.com/kc](https://rengwuxian.com/kc)
6 |
7 | 
--------------------------------------------------------------------------------
/app/src/main/res/values/themes.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
--------------------------------------------------------------------------------
/app/src/main/res/layout/layout_1.xml:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Wed Apr 24 21:53:00 CST 2024
2 | distributionBase=GRADLE_USER_HOME
3 | distributionPath=wrapper/dists
4 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
5 | zipStoreBase=GRADLE_USER_HOME
6 | zipStorePath=wrapper/dists
7 |
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/1_overview.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.runBlocking
4 |
5 | fun main() = runBlocking {
6 | // StateFlow
7 | // SharedFlow // event flow
8 | // Flow // data flow
9 | // Channel
10 | // async { }
11 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/ui/theme/Color.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines.ui.theme
2 |
3 | import androidx.compose.ui.graphics.Color
4 |
5 | val Purple80 = Color(0xFFD0BCFF)
6 | val PurpleGrey80 = Color(0xFFCCC2DC)
7 | val Pink80 = Color(0xFFEFB8C8)
8 |
9 | val Purple40 = Color(0xFF6650a4)
10 | val PurpleGrey40 = Color(0xFF625b71)
11 | val Pink40 = Color(0xFF7D5260)
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_1_basics/5_custom_suspend.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._1_basics
2 |
3 | import com.rengwuxian.coursecoroutines.common.Contributor
4 | import com.rengwuxian.coursecoroutines.common.gitHub
5 |
6 | suspend fun getRetrofitContributors(): List {
7 | return gitHub.contributors("square", "retrofit")
8 | }
9 |
10 | suspend fun customSuspendFun() {
11 |
12 | }
--------------------------------------------------------------------------------
/app/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | #FFBB86FC
4 | #FF6200EE
5 | #FF3700B3
6 | #FF03DAC5
7 | #FF018786
8 | #FF000000
9 | #FFFFFFFF
10 |
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_2_structured_concurrency/3_thread_stop.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._2_structured_concurrency
2 |
3 | import kotlinx.coroutines.runBlocking
4 | import kotlin.concurrent.thread
5 |
6 | fun main() = runBlocking {
7 | val thread = thread {
8 | println("Thread: I'm running!")
9 | Thread.sleep(200)
10 | println("Thread: I'm done!")
11 | }
12 | Thread.sleep(100)
13 | thread.stop()
14 | }
--------------------------------------------------------------------------------
/app/src/test/java/com/rengwuxian/coursecoroutines/ExampleUnitTest.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines
2 |
3 | import org.junit.Test
4 |
5 | import org.junit.Assert.*
6 |
7 | /**
8 | * Example local unit test, which will execute on the development machine (host).
9 | *
10 | * See [testing documentation](http://d.android.com/tools/testing).
11 | */
12 | class ExampleUnitTest {
13 | @Test
14 | fun addition_isCorrect() {
15 | assertEquals(4, 2 + 2)
16 | }
17 | }
--------------------------------------------------------------------------------
/app/src/main/res/xml/backup_rules.xml:
--------------------------------------------------------------------------------
1 |
8 |
9 |
13 |
--------------------------------------------------------------------------------
/settings.gradle.kts:
--------------------------------------------------------------------------------
1 | pluginManagement {
2 | repositories {
3 | google {
4 | content {
5 | includeGroupByRegex("com\\.android.*")
6 | includeGroupByRegex("com\\.google.*")
7 | includeGroupByRegex("androidx.*")
8 | }
9 | }
10 | mavenCentral()
11 | gradlePluginPortal()
12 | }
13 | }
14 | dependencyResolutionManagement {
15 | repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
16 | repositories {
17 | google()
18 | mavenCentral()
19 | }
20 | }
21 |
22 | rootProject.name = "CourseCoroutines"
23 | include(":app")
24 |
--------------------------------------------------------------------------------
/app/src/main/res/xml/data_extraction_rules.xml:
--------------------------------------------------------------------------------
1 |
6 |
7 |
8 |
12 |
13 |
19 |
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_3_scope_context/5_withContext_again.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._3_scope_context
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.coroutineScope
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.launch
7 | import kotlinx.coroutines.runBlocking
8 | import kotlinx.coroutines.withContext
9 | import kotlin.coroutines.EmptyCoroutineContext
10 |
11 | fun main() = runBlocking {
12 | val scope = CoroutineScope(EmptyCoroutineContext)
13 | scope.launch {
14 | withContext(coroutineContext) {
15 |
16 | }
17 | coroutineScope {
18 |
19 | }
20 | }
21 | delay(10000)
22 | }
--------------------------------------------------------------------------------
/app/src/main/res/layout/layout_2.xml:
--------------------------------------------------------------------------------
1 |
2 |
6 |
7 |
12 |
13 |
18 |
19 |
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/20_chunked.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.ExperimentalCoroutinesApi
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.flow.chunked
7 | import kotlinx.coroutines.flow.collect
8 | import kotlinx.coroutines.flow.flowOf
9 | import kotlinx.coroutines.launch
10 | import kotlinx.coroutines.runBlocking
11 | import kotlin.coroutines.EmptyCoroutineContext
12 |
13 | @OptIn(ExperimentalCoroutinesApi::class)
14 | fun main() = runBlocking {
15 | val scope = CoroutineScope(EmptyCoroutineContext)
16 | val flow1 = flowOf(1, 2, 3, 4, 5)
17 | scope.launch {
18 | flow1.chunked(2).collect { println("chunked: $it") }
19 | }
20 | delay(10000)
21 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_5_collaboration/4_ThreadLocal.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._5_collaboration
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.asContextElement
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.launch
7 | import kotlinx.coroutines.runBlocking
8 | import kotlinx.coroutines.withContext
9 | import kotlin.coroutines.EmptyCoroutineContext
10 |
11 | val kotlinLocalString = ThreadLocal()
12 |
13 | fun main() = runBlocking {
14 | val scope = CoroutineScope(EmptyCoroutineContext)
15 | scope.launch {
16 | val stringContext = kotlinLocalString.asContextElement("rengwuxian")
17 | withContext(stringContext) {
18 | delay(100)
19 | kotlinLocalString.get()
20 | }
21 | }
22 | delay(10000)
23 | }
--------------------------------------------------------------------------------
/app/proguard-rules.pro:
--------------------------------------------------------------------------------
1 | # Add project specific ProGuard rules here.
2 | # You can control the set of applied configuration files using the
3 | # proguardFiles setting in build.gradle.
4 | #
5 | # For more details, see
6 | # http://developer.android.com/guide/developing/tools/proguard.html
7 |
8 | # If your project uses WebView with JS, uncomment the following
9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | # public *;
13 | #}
14 |
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 |
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile
--------------------------------------------------------------------------------
/app/src/androidTest/java/com/rengwuxian/coursecoroutines/ExampleInstrumentedTest.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines
2 |
3 | import androidx.test.platform.app.InstrumentationRegistry
4 | import androidx.test.ext.junit.runners.AndroidJUnit4
5 |
6 | import org.junit.Test
7 | import org.junit.runner.RunWith
8 |
9 | import org.junit.Assert.*
10 |
11 | /**
12 | * Instrumented test, which will execute on an Android device.
13 | *
14 | * See [testing documentation](http://d.android.com/tools/testing).
15 | */
16 | @RunWith(AndroidJUnit4::class)
17 | class ExampleInstrumentedTest {
18 | @Test
19 | fun useAppContext() {
20 | // Context of the app under test.
21 | val appContext = InstrumentationRegistry.getInstrumentation().targetContext
22 | assertEquals("com.rengwuxian.coursecoroutines", appContext.packageName)
23 | }
24 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_2_structured_concurrency/9_CoroutineExceptionHandler.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._2_structured_concurrency
2 |
3 | import kotlinx.coroutines.CoroutineExceptionHandler
4 | import kotlinx.coroutines.CoroutineScope
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.launch
7 | import kotlinx.coroutines.runBlocking
8 | import kotlin.concurrent.thread
9 | import kotlin.coroutines.EmptyCoroutineContext
10 |
11 | fun main() = runBlocking {
12 | val scope = CoroutineScope(EmptyCoroutineContext)
13 | val handler = CoroutineExceptionHandler { _, exception ->
14 | println("Caught $exception")
15 | }
16 | scope.launch(handler) {
17 | launch {
18 | throw RuntimeException("Error!")
19 | }
20 | launch {
21 |
22 | }
23 | }
24 | delay(10000)
25 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_3_scope_context/6_CoroutineName.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._3_scope_context
2 |
3 | import kotlinx.coroutines.CoroutineName
4 | import kotlinx.coroutines.CoroutineScope
5 | import kotlinx.coroutines.Dispatchers
6 | import kotlinx.coroutines.delay
7 | import kotlinx.coroutines.launch
8 | import kotlinx.coroutines.runBlocking
9 | import kotlinx.coroutines.withContext
10 | import kotlin.concurrent.thread
11 | import kotlin.coroutines.EmptyCoroutineContext
12 |
13 | fun main() = runBlocking {
14 | thread { }.name = "MyThread"
15 | val name = CoroutineName("MyCoroutine")
16 | val scope = CoroutineScope(Dispatchers.IO + name)
17 | withContext(name) {
18 |
19 | }
20 | scope.launch {
21 | println("CoroutineName: ${coroutineContext[CoroutineName]?.name}")
22 | }
23 | delay(10000)
24 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_3_scope_context/1_scope_context.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._3_scope_context
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.Dispatchers
5 | import kotlinx.coroutines.GlobalScope
6 | import kotlinx.coroutines.Job
7 | import kotlinx.coroutines.delay
8 | import kotlinx.coroutines.job
9 | import kotlinx.coroutines.launch
10 | import kotlinx.coroutines.runBlocking
11 | import kotlin.coroutines.ContinuationInterceptor
12 | import kotlin.coroutines.CoroutineContext
13 |
14 | fun main() = runBlocking {
15 | val context = Dispatchers.IO + Job() + Job()
16 | val scope = CoroutineScope(Dispatchers.IO)
17 | val job = scope.launch {
18 | this.coroutineContext[Job]
19 | coroutineContext.job
20 | coroutineContext[ContinuationInterceptor]
21 | }
22 | delay(10000)
23 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_2_structured_concurrency/6_structural_cancellation.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._2_structured_concurrency
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.cancelAndJoin
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.launch
7 | import kotlinx.coroutines.runBlocking
8 | import kotlin.coroutines.EmptyCoroutineContext
9 | import kotlin.time.measureTime
10 |
11 | fun main() = runBlocking {
12 | val scope = CoroutineScope(EmptyCoroutineContext)
13 | val parentJob = scope.launch {
14 | val childJob = launch {
15 | println("Child job started")
16 | delay(3000)
17 | println("Child job finished")
18 | }
19 | }
20 | delay(1000)
21 | parentJob.cancel()
22 | measureTime { parentJob.join() }.also { println("Duration: $it") }
23 | delay(10000)
24 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/17_withIndex.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.collect
6 | import kotlinx.coroutines.flow.collectIndexed
7 | import kotlinx.coroutines.flow.flowOf
8 | import kotlinx.coroutines.flow.withIndex
9 | import kotlinx.coroutines.launch
10 | import kotlinx.coroutines.runBlocking
11 | import kotlin.coroutines.EmptyCoroutineContext
12 |
13 | fun main() = runBlocking {
14 | val scope = CoroutineScope(EmptyCoroutineContext)
15 | val flow1 = flowOf(1, 2, 3, 4, 5)
16 | scope.launch {
17 | flow1.withIndex().collect { (index, data) ->
18 | println("1: $index - $data")
19 | }
20 | flow1.collectIndexed { index, value ->
21 | println("1: $index - $value")
22 | }
23 | }
24 | delay(10000)
25 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/5_actor.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.ObsoleteCoroutinesApi
5 | import kotlinx.coroutines.channels.Channel
6 | import kotlinx.coroutines.channels.actor
7 | import kotlinx.coroutines.channels.produce
8 | import kotlinx.coroutines.delay
9 | import kotlinx.coroutines.launch
10 | import kotlinx.coroutines.runBlocking
11 | import kotlin.coroutines.EmptyCoroutineContext
12 |
13 | @OptIn(ObsoleteCoroutinesApi::class)
14 | fun main() = runBlocking {
15 | val scope = CoroutineScope(EmptyCoroutineContext)
16 | val sender = scope.actor {
17 | for (num in this) {
18 | println("Number: $num")
19 | }
20 | }
21 | scope.launch {
22 | for (num in 1..100) {
23 | sender.send(num)
24 | delay(1000)
25 | }
26 | }
27 | delay(10000)
28 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_3_scope_context/2_GlobalScope.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._3_scope_context
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.DelicateCoroutinesApi
5 | import kotlinx.coroutines.GlobalScope
6 | import kotlinx.coroutines.Job
7 | import kotlinx.coroutines.async
8 | import kotlinx.coroutines.cancel
9 | import kotlinx.coroutines.delay
10 | import kotlinx.coroutines.job
11 | import kotlinx.coroutines.launch
12 | import kotlinx.coroutines.runBlocking
13 | import kotlin.coroutines.EmptyCoroutineContext
14 |
15 | @OptIn(DelicateCoroutinesApi::class)
16 | fun main() = runBlocking {
17 | CoroutineScope(EmptyCoroutineContext).launch {
18 |
19 | }
20 | GlobalScope.launch {
21 |
22 | }
23 | GlobalScope.cancel()
24 | val job = GlobalScope.async {
25 | delay(1000)
26 | }
27 | println("job parent: ${job.parent}")
28 | delay(10000)
29 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/19_onEach.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.collect
6 | import kotlinx.coroutines.flow.filter
7 | import kotlinx.coroutines.flow.flowOf
8 | import kotlinx.coroutines.flow.onEach
9 | import kotlinx.coroutines.launch
10 | import kotlinx.coroutines.runBlocking
11 | import kotlin.coroutines.EmptyCoroutineContext
12 |
13 | fun main() = runBlocking {
14 | val scope = CoroutineScope(EmptyCoroutineContext)
15 | val flow1 = flowOf(1, 2, 3, 4, 5)
16 | scope.launch {
17 | flow1.onEach {
18 | println("onEach 1: $it")
19 | }.onEach {
20 | println("onEach 2: $it")
21 | }.filter {
22 | it % 2 == 0
23 | }.onEach {
24 | println("onEach 3: $it")
25 | }.collect {
26 | println("collect: $it")
27 | }
28 | }
29 | delay(10000)
30 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_3_scope_context/8_custom_CoroutineContext.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._3_scope_context
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.launch
6 | import kotlinx.coroutines.runBlocking
7 | import kotlin.coroutines.AbstractCoroutineContextElement
8 | import kotlin.coroutines.CoroutineContext
9 | import kotlin.coroutines.EmptyCoroutineContext
10 | import kotlin.coroutines.coroutineContext
11 |
12 | fun main() = runBlocking {
13 | val scope = CoroutineScope(EmptyCoroutineContext)
14 | val customContext = Logger()
15 | scope.launch(customContext) {
16 | coroutineContext[Logger]?.log()
17 | }
18 | delay(10000)
19 | }
20 |
21 | class Logger : AbstractCoroutineContextElement(Logger) {
22 | companion object Key : CoroutineContext.Key
23 |
24 | suspend fun log() {
25 | println("Current coroutine: $coroutineContext")
26 | }
27 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/11_distinctUntilChanged.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.distinctUntilChanged
6 | import kotlinx.coroutines.flow.distinctUntilChangedBy
7 | import kotlinx.coroutines.flow.flowOf
8 | import kotlinx.coroutines.launch
9 | import kotlinx.coroutines.runBlocking
10 | import kotlin.coroutines.EmptyCoroutineContext
11 |
12 | fun main() = runBlocking {
13 | val scope = CoroutineScope(EmptyCoroutineContext)
14 | val flow1 = flowOf("rengwuxian", "RengWuXian", "rengwuxian.com")
15 | scope.launch {
16 | flow1.distinctUntilChanged().collect { println("1: $it") } // == equals()
17 | flow1.distinctUntilChanged { a, b -> a.uppercase() == b.uppercase() }.collect { println("2: $it") }
18 | flow1.distinctUntilChangedBy { it.uppercase() }.collect { println("3: $it") }
19 | }
20 | delay(10000)
21 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/2_produce.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import com.rengwuxian.coursecoroutines.common.gitHub
4 | import kotlinx.coroutines.CoroutineScope
5 | import kotlinx.coroutines.ExperimentalCoroutinesApi
6 | import kotlinx.coroutines.channels.produce
7 | import kotlinx.coroutines.delay
8 | import kotlinx.coroutines.isActive
9 | import kotlinx.coroutines.launch
10 | import kotlinx.coroutines.runBlocking
11 | import kotlin.coroutines.EmptyCoroutineContext
12 |
13 | @OptIn(ExperimentalCoroutinesApi::class)
14 | fun main() = runBlocking {
15 | val scope = CoroutineScope(EmptyCoroutineContext)
16 | val receiver = scope.produce {
17 | while (isActive) {
18 | val data = gitHub.contributors("square", "retrofit")
19 | send(data)
20 | }
21 | }
22 | launch {
23 | delay(5000)
24 | while (isActive) {
25 | println("Contributors: ${receiver.receive()}")
26 | }
27 | }
28 | delay(10000)
29 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/14_drop_take.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.collect
6 | import kotlinx.coroutines.flow.drop
7 | import kotlinx.coroutines.flow.dropWhile
8 | import kotlinx.coroutines.flow.flowOf
9 | import kotlinx.coroutines.flow.take
10 | import kotlinx.coroutines.flow.takeWhile
11 | import kotlinx.coroutines.launch
12 | import kotlinx.coroutines.runBlocking
13 | import kotlin.coroutines.EmptyCoroutineContext
14 |
15 | fun main() = runBlocking {
16 | val scope = CoroutineScope(EmptyCoroutineContext)
17 | val flow1 = flowOf(1, 2, 3, 4, 5)
18 | scope.launch {
19 | flow1.drop(2).collect { println("1: $it") }
20 | flow1.dropWhile { it != 3 }.collect { println("2: $it") }
21 | flow1.take(2).collect { println("3: $it") }
22 | flow1.takeWhile { it != 3 }.collect { println("4: $it") }
23 | }
24 | delay(10000)
25 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/32_StateFlow.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.MutableStateFlow
6 | import kotlinx.coroutines.flow.asStateFlow
7 | import kotlinx.coroutines.flow.collect
8 | import kotlinx.coroutines.flow.flow
9 | import kotlinx.coroutines.flow.stateIn
10 | import kotlinx.coroutines.launch
11 | import kotlinx.coroutines.runBlocking
12 | import kotlin.coroutines.EmptyCoroutineContext
13 |
14 | fun main() = runBlocking {
15 | val scope = CoroutineScope(EmptyCoroutineContext)
16 | val name = MutableStateFlow("rengwuxian")
17 | val flow1 = flow {
18 | emit(1)
19 | delay(1000)
20 | emit(2)
21 | delay(1000)
22 | emit(3)
23 | }
24 | name.asStateFlow()
25 | val state = flow1.stateIn(scope)
26 | scope.launch {
27 | name.collect {
28 | println("State: $it")
29 | }
30 | }
31 | scope.launch {
32 | delay(2000)
33 | name.emit("扔物线")
34 | }
35 | delay(10000)
36 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_3_scope_context/3_coroutineContext.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._3_scope_context
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.GlobalScope
5 | import kotlinx.coroutines.currentCoroutineContext
6 | import kotlinx.coroutines.delay
7 | import kotlinx.coroutines.flow.flow
8 | import kotlinx.coroutines.launch
9 | import kotlinx.coroutines.runBlocking
10 | import kotlin.coroutines.ContinuationInterceptor
11 | import kotlin.coroutines.EmptyCoroutineContext
12 | import kotlin.coroutines.coroutineContext
13 |
14 | fun main() = runBlocking {
15 | val scope = CoroutineScope(EmptyCoroutineContext)
16 | scope.launch {
17 | showDispatcher()
18 | }
19 | delay(10000)
20 | }
21 |
22 | private fun flowFun() {
23 | flow {
24 | coroutineContext
25 | }
26 | GlobalScope.launch {
27 | flow {
28 | currentCoroutineContext()
29 | }
30 | }
31 | }
32 |
33 | private suspend fun showDispatcher() {
34 | delay(1000)
35 | println("Dispatcher: ${coroutineContext[ContinuationInterceptor]}")
36 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/12_custom_flow.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.Flow
6 | import kotlinx.coroutines.flow.FlowCollector
7 | import kotlinx.coroutines.flow.channelFlow
8 | import kotlinx.coroutines.flow.collect
9 | import kotlinx.coroutines.flow.flow
10 | import kotlinx.coroutines.flow.flowOf
11 | import kotlinx.coroutines.launch
12 | import kotlinx.coroutines.runBlocking
13 | import kotlin.coroutines.EmptyCoroutineContext
14 |
15 | fun main() = runBlocking {
16 | val scope = CoroutineScope(EmptyCoroutineContext)
17 | val flow1 = flowOf(1, 2, 3)
18 | scope.launch {
19 | flow1.customOperator().collect { println("1: $it") }
20 | flow1.double().collect { println("2: $it") }
21 | }
22 | delay(10000)
23 | }
24 |
25 | fun Flow.customOperator(): Flow = flow {
26 | collect {
27 | emit(it)
28 | emit(it)
29 | }
30 | }
31 |
32 | fun Flow.double(): Flow = channelFlow {
33 | collect {
34 | send(it * 2)
35 | }
36 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_2_structured_concurrency/12_SupervisorJob.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._2_structured_concurrency
2 |
3 | import kotlinx.coroutines.CoroutineExceptionHandler
4 | import kotlinx.coroutines.CoroutineScope
5 | import kotlinx.coroutines.Job
6 | import kotlinx.coroutines.SupervisorJob
7 | import kotlinx.coroutines.delay
8 | import kotlinx.coroutines.job
9 | import kotlinx.coroutines.launch
10 | import kotlinx.coroutines.runBlocking
11 | import kotlinx.coroutines.withContext
12 | import kotlin.coroutines.EmptyCoroutineContext
13 |
14 | fun main() = runBlocking {
15 | val scope = CoroutineScope(SupervisorJob())
16 | val supervisorJob = SupervisorJob()
17 | val job = Job()
18 | scope.launch {
19 | val handler = CoroutineExceptionHandler { _, exception ->
20 | println("Caught in handler: $exception")
21 | }
22 | launch(SupervisorJob(coroutineContext.job) + handler) {
23 | launch {
24 | throw RuntimeException("Error!")
25 | }
26 | }
27 | }
28 | delay(1000)
29 | println("Parent Job cancelled: ${job.isCancelled}")
30 | delay(10000)
31 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/ui/theme/Type.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines.ui.theme
2 |
3 | import androidx.compose.material3.Typography
4 | import androidx.compose.ui.text.TextStyle
5 | import androidx.compose.ui.text.font.FontFamily
6 | import androidx.compose.ui.text.font.FontWeight
7 | import androidx.compose.ui.unit.sp
8 |
9 | // Set of Material typography styles to start with
10 | val Typography = Typography(
11 | bodyLarge = TextStyle(
12 | fontFamily = FontFamily.Default,
13 | fontWeight = FontWeight.Normal,
14 | fontSize = 16.sp,
15 | lineHeight = 24.sp,
16 | letterSpacing = 0.5.sp
17 | )
18 | /* Other default text styles to override
19 | titleLarge = TextStyle(
20 | fontFamily = FontFamily.Default,
21 | fontWeight = FontWeight.Normal,
22 | fontSize = 22.sp,
23 | lineHeight = 28.sp,
24 | letterSpacing = 0.sp
25 | ),
26 | labelSmall = TextStyle(
27 | fontFamily = FontFamily.Default,
28 | fontWeight = FontWeight.Medium,
29 | fontSize = 11.sp,
30 | lineHeight = 16.sp,
31 | letterSpacing = 0.5.sp
32 | )
33 | */
34 | )
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/30_shareIn.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.cancel
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.flow.SharingStarted
7 | import kotlinx.coroutines.flow.flow
8 | import kotlinx.coroutines.flow.shareIn
9 | import kotlinx.coroutines.launch
10 | import kotlinx.coroutines.runBlocking
11 | import kotlin.coroutines.EmptyCoroutineContext
12 |
13 | fun main() = runBlocking {
14 | val scope = CoroutineScope(EmptyCoroutineContext)
15 | val flow1 = flow {
16 | emit(1)
17 | delay(1000)
18 | emit(2)
19 | delay(1000)
20 | emit(3)
21 | }
22 | val sharedFlow = flow1.shareIn(scope, SharingStarted.WhileSubscribed(), 2)
23 | scope.launch {
24 | val parent = this
25 | launch {
26 | delay(4000)
27 | parent.cancel()
28 | }
29 | delay(1500)
30 | sharedFlow.collect {
31 | println("SharedFlow in Coroutine 1: $it")
32 | }
33 | }
34 | scope.launch {
35 | delay(5000)
36 | sharedFlow.collect {
37 | println("SharedFlow in Coroutine 2: $it")
38 | }
39 | }
40 | delay(10000)
41 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/6_flow.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.Dispatchers
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.flow.flow
7 | import kotlinx.coroutines.flow.map
8 | import kotlinx.coroutines.launch
9 | import kotlinx.coroutines.runBlocking
10 | import kotlinx.coroutines.withContext
11 | import kotlin.coroutines.EmptyCoroutineContext
12 |
13 | fun main() = runBlocking {
14 | val list = buildList {
15 | // while (true) {
16 | add(getData())
17 | // }
18 | }
19 | for (num in list) {
20 | println("List item: $num")
21 | }
22 | val nums = sequence {
23 | while (true) {
24 | yield(1)
25 | }
26 | }.map { "number $it" }
27 | for (num in nums) {
28 | println(num)
29 | }
30 |
31 | val numsFlow = flow {
32 | while (true) {
33 | emit(getData())
34 | }
35 | }.map { "number $it" }
36 | val scope = CoroutineScope(EmptyCoroutineContext)
37 | scope.launch {
38 | numsFlow.collect {
39 | println(it)
40 | }
41 | }
42 | delay(10000)
43 | }
44 |
45 | suspend fun getData(): Int {
46 | return 1
47 | }
48 |
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_2_structured_concurrency/11_async_exception.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._2_structured_concurrency
2 |
3 | import kotlinx.coroutines.CoroutineExceptionHandler
4 | import kotlinx.coroutines.CoroutineScope
5 | import kotlinx.coroutines.Job
6 | import kotlinx.coroutines.async
7 | import kotlinx.coroutines.delay
8 | import kotlinx.coroutines.launch
9 | import kotlinx.coroutines.runBlocking
10 | import kotlin.coroutines.EmptyCoroutineContext
11 |
12 | fun main() = runBlocking {
13 | val scope = CoroutineScope(EmptyCoroutineContext)
14 | val handler = CoroutineExceptionHandler { _, exception ->
15 | println("Caught in Coroutine: $exception")
16 | }
17 | scope.async/*(handler)*/ {
18 | val deferred = async {
19 | delay(1000)
20 | throw RuntimeException("Error!")
21 | }
22 | launch(Job()) {
23 | try {
24 | deferred.await()
25 | } catch (e: Exception) {
26 | println("Caught in await: $e")
27 | }
28 | try {
29 | delay(1000)
30 | } catch (e: Exception) {
31 | println("Caught in delay: $e")
32 | }
33 | }
34 | // delay(100)
35 | // cancel()
36 | }
37 | delay(10000)
38 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_2_structured_concurrency/1_whats_a_coroutine.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._2_structured_concurrency
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.CoroutineStart
5 | import kotlinx.coroutines.Dispatchers
6 | import kotlinx.coroutines.Job
7 | import kotlinx.coroutines.async
8 | import kotlinx.coroutines.cancelChildren
9 | import kotlinx.coroutines.launch
10 | import kotlinx.coroutines.runBlocking
11 | import kotlin.concurrent.thread
12 | import kotlin.coroutines.ContinuationInterceptor
13 | import kotlin.coroutines.EmptyCoroutineContext
14 |
15 | fun main() = runBlocking {
16 | val scope = CoroutineScope(Dispatchers.IO)
17 | var innerJob: Job? = null
18 | var innerScope: CoroutineScope? = null
19 | val outerJob = scope.launch(Dispatchers.Default) {
20 | innerJob = coroutineContext[Job]
21 | innerScope = this
22 | launch {
23 |
24 | }
25 | }
26 | outerJob.cancel()
27 |
28 | scope.async {
29 |
30 | }
31 | println("outerJob: $outerJob")
32 | println("innerJob: $innerJob")
33 | println("outerJob === innerJob: ${outerJob === innerJob}")
34 | println("outerJob === innerScope: ${outerJob === innerScope}")
35 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/9_collect.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.Dispatchers
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.flow.collectIndexed
7 | import kotlinx.coroutines.flow.collectLatest
8 | import kotlinx.coroutines.flow.flow
9 | import kotlinx.coroutines.flow.flowOn
10 | import kotlinx.coroutines.flow.launchIn
11 | import kotlinx.coroutines.flow.onEach
12 | import kotlinx.coroutines.launch
13 | import kotlinx.coroutines.runBlocking
14 | import kotlinx.coroutines.withContext
15 | import kotlin.coroutines.EmptyCoroutineContext
16 |
17 | fun main() = runBlocking {
18 | val flow = flow {
19 | /*launch(Dispatchers.IO) {
20 | delay(2000)
21 | emit(2)
22 | }*/
23 | delay(1000)
24 | emit(1)
25 | }
26 | val scope = CoroutineScope(EmptyCoroutineContext)
27 |
28 | flow.onEach {
29 | println("flow: $it")
30 | }.launchIn(scope)
31 |
32 | scope.launch(Dispatchers.Default) {
33 | flow.collect {
34 | println("flow: $it")
35 | }
36 | flow.collectIndexed { index, value -> }
37 | flow.collectLatest { }
38 | }
39 | delay(10000)
40 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/24_onStart_onCompletion_onEmpty.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.catch
6 | import kotlinx.coroutines.flow.flow
7 | import kotlinx.coroutines.flow.onCompletion
8 | import kotlinx.coroutines.flow.onEmpty
9 | import kotlinx.coroutines.flow.onStart
10 | import kotlinx.coroutines.launch
11 | import kotlinx.coroutines.runBlocking
12 | import kotlin.coroutines.EmptyCoroutineContext
13 |
14 | fun main() = runBlocking {
15 | val scope = CoroutineScope(EmptyCoroutineContext)
16 | val flow1 = flow {
17 | try {
18 | for (i in 1..5) {
19 | emit(i)
20 | }
21 | } catch (e: Exception) {
22 | println("try / catch: $e")
23 | }
24 | }.onStart {
25 | println("onStart 1")
26 | throw RuntimeException("onStart error")
27 | }
28 | .onStart { println("onStart 2") }
29 | .onCompletion {
30 | println("onCompletion: $it")
31 | }.onEmpty { println("onEmpty") }
32 | .catch { println("catch: $it") }
33 | scope.launch {
34 | flow1.collect {
35 | println("Data: $it")
36 | }
37 | }
38 | delay(10000)
39 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_2_structured_concurrency/10_structured_exception.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._2_structured_concurrency
2 |
3 | import kotlinx.coroutines.CoroutineExceptionHandler
4 | import kotlinx.coroutines.CoroutineScope
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.launch
7 | import kotlinx.coroutines.runBlocking
8 | import kotlin.coroutines.EmptyCoroutineContext
9 | import kotlin.system.exitProcess
10 |
11 | fun main() = runBlocking {
12 | Thread.setDefaultUncaughtExceptionHandler { t, e ->
13 | println("Caught default: $e")
14 | exitProcess(1)
15 | }
16 | /*val thread = Thread {
17 | try {
18 |
19 | } catch (e: NullPointerException) {
20 |
21 | }
22 | throw RuntimeException("Thread error!")
23 | }*/
24 | /*thread.setUncaughtExceptionHandler { t, e ->
25 | println("Caught $e")
26 | }*/
27 | // thread.start()
28 | val scope = CoroutineScope(EmptyCoroutineContext)
29 | val handler = CoroutineExceptionHandler { _, exception ->
30 | println("Caught in Coroutine: $exception")
31 | }
32 | scope.launch(handler) {
33 | launch {
34 | throw RuntimeException("Error!")
35 | }
36 | launch {
37 |
38 | }
39 | }
40 | delay(10000)
41 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/23_retry.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.flow
6 | import kotlinx.coroutines.flow.map
7 | import kotlinx.coroutines.flow.retry
8 | import kotlinx.coroutines.flow.retryWhen
9 | import kotlinx.coroutines.launch
10 | import kotlinx.coroutines.runBlocking
11 | import java.util.concurrent.TimeoutException
12 | import kotlin.coroutines.EmptyCoroutineContext
13 |
14 | fun main() = runBlocking {
15 | val scope = CoroutineScope(EmptyCoroutineContext)
16 | val flow1 = flow {
17 | for (i in 1..5) {
18 | // 数据库读数据
19 | // 网络请求
20 | if (i == 3) {
21 | throw RuntimeException("flow() error")
22 | } else {
23 | emit(i)
24 | }
25 | }
26 | }.map { it * 2 }.retry(3) {
27 | it is RuntimeException
28 | }/*.retryWhen { cause, attempt -> }*/
29 | scope.launch {
30 | try {
31 | flow1.collect {
32 | println("Data: $it")
33 | }
34 | } catch (e: TimeoutException) {
35 | println("Network error: $e")
36 | } catch (e: RuntimeException) {
37 | println("RuntimeException: $e")
38 | }
39 | }
40 | delay(10000)
41 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_3_scope_context/7_CoroutineContext.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._3_scope_context
2 |
3 | import kotlinx.coroutines.CoroutineDispatcher
4 | import kotlinx.coroutines.CoroutineExceptionHandler
5 | import kotlinx.coroutines.CoroutineName
6 | import kotlinx.coroutines.CoroutineScope
7 | import kotlinx.coroutines.Dispatchers
8 | import kotlinx.coroutines.Job
9 | import kotlinx.coroutines.delay
10 | import kotlinx.coroutines.launch
11 | import kotlinx.coroutines.runBlocking
12 | import kotlin.coroutines.ContinuationInterceptor
13 | import kotlin.coroutines.EmptyCoroutineContext
14 |
15 | @OptIn(ExperimentalStdlibApi::class)
16 | fun main() = runBlocking {
17 | val job1 = Job()
18 | val job2 = Job()
19 | val scope = CoroutineScope(Dispatchers.IO + job1
20 | + CoroutineName("MyCoroutine") + job2)
21 | // [[CoroutineName(MyCoroutine), job2], Dispatchers.IO]
22 | println("job1: $job1, job2: $job2")
23 | println("CoroutineContext: ${scope.coroutineContext}")
24 | scope.launch {
25 | val job: Job? = coroutineContext[Job]
26 | val interceptor: CoroutineDispatcher? = coroutineContext[CoroutineDispatcher]
27 | println("coroutineContext: $coroutineContext")
28 | println("coroutineContext after minusKey() ${coroutineContext.minusKey(Job)}")
29 | }
30 | delay(10000)
31 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/15_map.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.collect
6 | import kotlinx.coroutines.flow.filter
7 | import kotlinx.coroutines.flow.filterNotNull
8 | import kotlinx.coroutines.flow.flow
9 | import kotlinx.coroutines.flow.flowOf
10 | import kotlinx.coroutines.flow.map
11 | import kotlinx.coroutines.flow.mapLatest
12 | import kotlinx.coroutines.flow.mapNotNull
13 | import kotlinx.coroutines.launch
14 | import kotlinx.coroutines.runBlocking
15 | import kotlin.coroutines.EmptyCoroutineContext
16 |
17 | fun main() = runBlocking {
18 | val scope = CoroutineScope(EmptyCoroutineContext)
19 | val flow1 = flowOf(1, 2, 3, 4, 5)
20 | val flow2 = flow {
21 | delay(100)
22 | emit(1)
23 | delay(100)
24 | emit(2)
25 | delay(100)
26 | emit(3)
27 | }
28 | scope.launch {
29 | flow1.map { if (it == 3) null else it + 1 }.collect { println("1: $it") }
30 | flow1.mapNotNull { if (it == 3) null else it + 1 }.collect { println("2: $it") }
31 | flow1.map { if (it == 3) null else it + 1 }.filterNotNull()
32 | flow1.filter { it != 3 }.map { it + 1 }
33 | flow2.mapLatest { delay(120); it + 1}.collect { println("3: $it") }
34 | }
35 | delay(10000)
36 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/7_flow_use_case.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.Dispatchers
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.flow.Flow
7 | import kotlinx.coroutines.flow.flow
8 | import kotlinx.coroutines.launch
9 | import kotlinx.coroutines.runBlocking
10 | import kotlinx.coroutines.withContext
11 | import kotlin.coroutines.EmptyCoroutineContext
12 |
13 | fun main() = runBlocking {
14 | val numsFlow = flow {
15 | emit(1)
16 | delay(100)
17 | emit(2)
18 | }
19 | val scope = CoroutineScope(EmptyCoroutineContext)
20 | scope.launch {
21 | // showWeather(weatherFlow)
22 | weatherFlow.collect {
23 | println("Weather: $it")
24 | }
25 | // log("done")
26 | /*numsFlow.collect {
27 | println("A: $it")
28 | }*/
29 | }
30 | scope.launch {
31 | delay(50)
32 | numsFlow.collect {
33 | println("B: $it")
34 | }
35 | }
36 | delay(10000)
37 | }
38 |
39 | val weatherFlow = flow {
40 | while (true) {
41 | emit(getWeather())
42 | delay(60000)
43 | }
44 | }
45 |
46 | suspend fun showWeather(flow: Flow) {
47 | flow.collect {
48 | println("Weather: $it")
49 | }
50 | }
51 |
52 | suspend fun getWeather() = withContext(Dispatchers.IO) {
53 | "Sunny"
54 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_1_basics/12_runBlocking.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._1_basics
2 |
3 | import android.os.Bundle
4 | import android.widget.TextView
5 | import androidx.activity.ComponentActivity
6 | import androidx.lifecycle.lifecycleScope
7 | import com.rengwuxian.coursecoroutines.R
8 | import com.rengwuxian.coursecoroutines.common.gitHub
9 | import kotlinx.coroutines.Dispatchers
10 | import kotlinx.coroutines.async
11 | import kotlinx.coroutines.coroutineScope
12 | import kotlinx.coroutines.launch
13 | import kotlinx.coroutines.runBlocking
14 | import kotlin.concurrent.thread
15 |
16 | fun main() = runBlocking {
17 | val contributors = gitHub.contributors("square", "retrofit")
18 | launch {
19 |
20 | }
21 | }
22 |
23 | class RunBlockingActivity : ComponentActivity() {
24 | private lateinit var infoTextView: TextView
25 |
26 | override fun onCreate(savedInstanceState: Bundle?) {
27 | super.onCreate(savedInstanceState)
28 | setContentView(R.layout.layout_1)
29 | infoTextView = findViewById(R.id.infoTextView)
30 |
31 | lifecycleScope.launch(Dispatchers.Main.immediate) {
32 |
33 | }
34 | println()
35 | lifecycleScope.async { }
36 | blockingContributors()
37 | println()
38 | }
39 |
40 | private fun blockingContributors() = runBlocking {
41 | gitHub.contributors("square", "retrofit")
42 | }
43 |
44 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/10_filter.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.collect
6 | import kotlinx.coroutines.flow.filter
7 | import kotlinx.coroutines.flow.filterIsInstance
8 | import kotlinx.coroutines.flow.filterNot
9 | import kotlinx.coroutines.flow.filterNotNull
10 | import kotlinx.coroutines.flow.flow
11 | import kotlinx.coroutines.flow.flowOf
12 | import kotlinx.coroutines.launch
13 | import kotlinx.coroutines.runBlocking
14 | import kotlin.coroutines.EmptyCoroutineContext
15 |
16 | fun main() = runBlocking {
17 | val scope = CoroutineScope(EmptyCoroutineContext)
18 | val flow1 = flowOf(1, 2, null, 3, null, 4, 5) // Int?
19 | val flow2 = flowOf(1, 2, 3, "rengwuxian.com", "扔物线",
20 | listOf("A", "B"), listOf(1, 2))
21 | scope.launch {
22 | flow1.filterNotNull().filter { it % 2 == 0 }.collect { println("1: $it") }
23 | flow1.filterNotNull().filterNot { it % 2 == 0 }.collect { println("2: $it") }
24 | flow2.filterIsInstance>().collect { println("3: $it") }
25 | flow2.filterIsInstance(List::class).collect { println("4: $it") }
26 | flow2.filter { it is List<*> && it.firstOrNull()?.let { item -> item is String } == true }
27 | .collect { println("5: $it") }
28 | }
29 | delay(10000)
30 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_2_structured_concurrency/2_parent_children.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._2_structured_concurrency
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.ExperimentalCoroutinesApi
5 | import kotlinx.coroutines.Job
6 | import kotlinx.coroutines.delay
7 | import kotlinx.coroutines.launch
8 | import kotlinx.coroutines.runBlocking
9 | import kotlin.coroutines.EmptyCoroutineContext
10 |
11 | @OptIn(ExperimentalCoroutinesApi::class)
12 | fun main() = runBlocking {
13 | val scope = CoroutineScope(EmptyCoroutineContext)
14 | val initJob = scope.launch {
15 | launch { }
16 | launch { }
17 | }
18 | scope.launch {
19 | initJob.join()
20 | // ???
21 | }
22 | var innerJob: Job? = null
23 | val job = scope.launch {
24 | launch(Job()) {
25 | delay(100)
26 | }
27 | // val customJob = Job()
28 | // innerJob = launch(customJob) {
29 | // delay(100)
30 | // }
31 | }
32 | val startTime = System.currentTimeMillis()
33 | job.join()
34 | val duration = System.currentTimeMillis() - startTime
35 | println("duration: $duration")
36 | // val children = job.children
37 | // println("children count: ${children.count()}")
38 | // println("innerJob === children.first(): ${innerJob === children.first()}")
39 | // println("innerJob.parent === job: ${innerJob?.parent === job}")
40 | }
--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
1 | # Project-wide Gradle settings.
2 | # IDE (e.g. Android Studio) users:
3 | # Gradle settings configured through the IDE *will override*
4 | # any settings specified in this file.
5 | # For more details on how to configure your build environment visit
6 | # http://www.gradle.org/docs/current/userguide/build_environment.html
7 | # Specifies the JVM arguments used for the daemon process.
8 | # The setting is particularly useful for tweaking memory settings.
9 | org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
10 | # When configured, Gradle will run in incubating parallel mode.
11 | # This option should only be used with decoupled projects. For more details, visit
12 | # https://developer.android.com/r/tools/gradle-multi-project-decoupled-projects
13 | # org.gradle.parallel=true
14 | # AndroidX package structure to make it clearer which packages are bundled with the
15 | # Android operating system, and which are packaged with your app's APK
16 | # https://developer.android.com/topic/libraries/support-library/androidx-rn
17 | android.useAndroidX=true
18 | # Kotlin code style for this project: "official" or "obsolete":
19 | kotlin.code.style=official
20 | # Enables namespacing of each library's R class so that its R class includes only the
21 | # resources declared in the library itself and none from the library's dependencies,
22 | # thereby reducing the size of the R class for that library
23 | android.nonTransitiveRClass=true
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/3_channel.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import com.rengwuxian.coursecoroutines.common.Contributor
4 | import com.rengwuxian.coursecoroutines.common.gitHub
5 | import kotlinx.coroutines.CoroutineScope
6 | import kotlinx.coroutines.ExperimentalCoroutinesApi
7 | import kotlinx.coroutines.channels.Channel
8 | import kotlinx.coroutines.channels.produce
9 | import kotlinx.coroutines.delay
10 | import kotlinx.coroutines.isActive
11 | import kotlinx.coroutines.launch
12 | import kotlinx.coroutines.runBlocking
13 | import kotlin.coroutines.EmptyCoroutineContext
14 |
15 | @OptIn(ExperimentalCoroutinesApi::class)
16 | fun main() = runBlocking {
17 | val scope = CoroutineScope(EmptyCoroutineContext)
18 | val channel = Channel>()
19 | scope.launch {
20 | channel.send(gitHub.contributors("square", "retrofit"))
21 | }
22 | scope.launch {
23 | while (isActive) {
24 | channel.receive()
25 | }
26 | }
27 | scope.launch {
28 | while (isActive) {
29 | channel.receive()
30 | }
31 | }
32 | val receiver = scope.produce {
33 | while (isActive) {
34 | val data = gitHub.contributors("square", "retrofit")
35 | send(data)
36 | }
37 | }
38 | launch {
39 | delay(5000)
40 | while (isActive) {
41 | println("Contributors: ${receiver.receive()}")
42 | }
43 | }
44 | delay(10000)
45 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/common/Common.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines.common
2 |
3 | import retrofit2.Retrofit
4 | import retrofit2.adapter.rxjava3.RxJava3CallAdapterFactory
5 | import retrofit2.converter.gson.GsonConverterFactory
6 | import retrofit2.mock.MockRetrofit
7 | import retrofit2.mock.NetworkBehavior
8 | import java.util.concurrent.TimeoutException
9 |
10 | private val retrofit =
11 | Retrofit.Builder().baseUrl(GITHUB_API)
12 | .addCallAdapterFactory(RxJava3CallAdapterFactory.create())
13 | .addConverterFactory(GsonConverterFactory.create())
14 | .build()
15 | //val gitHub: GitHub = retrofit.create(GitHub::class.java
16 |
17 | // Create a MockRetrofit object with a NetworkBehavior which manages the fake behavior of calls.
18 | private val behavior = NetworkBehavior.create()
19 | private val mockRetrofit = MockRetrofit.Builder(retrofit).networkBehavior(behavior).build()
20 | private val delegate = mockRetrofit.create(GitHub::class.java)
21 | val gitHub: GitHub = MockGitHub(delegate)
22 | private val unstableBehavior = NetworkBehavior.create().apply {
23 | setFailurePercent(40)
24 | setFailureException(TimeoutException("Connection time out!"))
25 | }
26 | private val mockUnstableRetrofit = MockRetrofit.Builder(retrofit).networkBehavior(unstableBehavior).build()
27 | private val unstableDelegate = mockUnstableRetrofit.create(GitHub::class.java)
28 | val unstableGitHub: GitHub = MockGitHub(unstableDelegate)
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/26_buffer.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.Dispatchers
5 | import kotlinx.coroutines.channels.BufferOverflow
6 | import kotlinx.coroutines.channels.Channel.Factory.CONFLATED
7 | import kotlinx.coroutines.delay
8 | import kotlinx.coroutines.flow.buffer
9 | import kotlinx.coroutines.flow.collectLatest
10 | import kotlinx.coroutines.flow.conflate
11 | import kotlinx.coroutines.flow.flow
12 | import kotlinx.coroutines.flow.flowOn
13 | import kotlinx.coroutines.flow.map
14 | import kotlinx.coroutines.flow.mapLatest
15 | import kotlinx.coroutines.launch
16 | import kotlinx.coroutines.runBlocking
17 | import kotlinx.coroutines.withContext
18 | import kotlin.concurrent.thread
19 | import kotlin.coroutines.EmptyCoroutineContext
20 |
21 | fun main() = runBlocking {
22 | val scope = CoroutineScope(EmptyCoroutineContext)
23 | val start = System.currentTimeMillis()
24 | val flow1 = flow {
25 | for (i in 1..5) {
26 | emit(i)
27 | println("Emitted: $i - ${System.currentTimeMillis() - start}ms")
28 | }
29 | }.buffer(1)
30 | .flowOn(Dispatchers.IO)
31 | .buffer(2)
32 | // .conflate()
33 | .map { it + 1 }
34 | .map { it * 2 }
35 | scope.launch {
36 | flow1.mapLatest { it }.buffer(0).collect {
37 | delay(1000)
38 | println("Data: $it")
39 | }
40 | }
41 | delay(10000)
42 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/MainActivity.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines
2 |
3 | import android.os.Bundle
4 | import androidx.activity.ComponentActivity
5 | import androidx.activity.compose.setContent
6 | import androidx.activity.enableEdgeToEdge
7 | import androidx.compose.foundation.layout.fillMaxSize
8 | import androidx.compose.foundation.layout.padding
9 | import androidx.compose.material3.Scaffold
10 | import androidx.compose.material3.Text
11 | import androidx.compose.runtime.Composable
12 | import androidx.compose.ui.Modifier
13 | import androidx.compose.ui.tooling.preview.Preview
14 | import com.rengwuxian.coursecoroutines.ui.theme.CourseCoroutinesTheme
15 |
16 | class MainActivity : ComponentActivity() {
17 | override fun onCreate(savedInstanceState: Bundle?) {
18 | super.onCreate(savedInstanceState)
19 | enableEdgeToEdge()
20 | setContent {
21 | CourseCoroutinesTheme {
22 | Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
23 | Greeting(
24 | name = "Android",
25 | modifier = Modifier.padding(innerPadding)
26 | )
27 | }
28 | }
29 | }
30 | }
31 | }
32 |
33 | @Composable
34 | fun Greeting(name: String, modifier: Modifier = Modifier) {
35 | Text(
36 | text = "Hello $name!",
37 | modifier = modifier
38 | )
39 | }
40 |
41 | @Preview(showBackground = true)
42 | @Composable
43 | fun GreetingPreview() {
44 | CourseCoroutinesTheme {
45 | Greeting("Android")
46 | }
47 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_2_structured_concurrency/4_thread_interrupt.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._2_structured_concurrency
2 |
3 | import kotlinx.coroutines.runBlocking
4 | import java.util.concurrent.CountDownLatch
5 | import kotlin.concurrent.thread
6 |
7 | fun main() = runBlocking {
8 | val thread = object : Thread() {
9 | override fun run() {
10 | println("Thread: I'm running!")
11 | try {
12 | Thread.sleep(200)
13 | } catch (e: InterruptedException) {
14 | println("isInterrupted: $isInterrupted")
15 | println("Clearing ...")
16 | return
17 | }
18 | val lock = Object()
19 | try {
20 | lock.wait()
21 | } catch (e: InterruptedException) {
22 | println("isInterrupted: $isInterrupted")
23 | println("Clearing ...")
24 | return
25 | }
26 | val newThread = thread {
27 |
28 | }
29 | newThread.join()
30 | val latch = CountDownLatch(3)
31 | latch.await()
32 | /*var count = 0
33 | while (true) {
34 | if (isInterrupted) {
35 | // clear
36 | return
37 | }
38 | count++
39 | if (count % 100_000_000 == 0) {
40 | println(count)
41 | }
42 | if (count % 1_000_000_000 == 0) {
43 | break
44 | }
45 | }*/
46 | println("Thread: I'm done!")
47 | }
48 | }.apply { start() }
49 | Thread.sleep(100)
50 | thread.interrupt()
51 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/22_catch.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import com.rengwuxian.coursecoroutines.common.unstableGitHub
4 | import kotlinx.coroutines.CoroutineScope
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.flow.catch
7 | import kotlinx.coroutines.flow.flow
8 | import kotlinx.coroutines.flow.onEach
9 | import kotlinx.coroutines.launch
10 | import kotlinx.coroutines.runBlocking
11 | import java.util.concurrent.TimeoutException
12 | import kotlin.coroutines.EmptyCoroutineContext
13 |
14 | fun main() = runBlocking {
15 | val scope = CoroutineScope(EmptyCoroutineContext)
16 | val flow1 = flow {
17 | for (i in 1..5) {
18 | // 数据库读数据
19 | // 网络请求
20 | if (i == 3) {
21 | throw RuntimeException("flow() error")
22 | } else {
23 | emit(i)
24 | }
25 | }
26 | }.catch {
27 | println("catch(): $it")
28 | emit(100)
29 | emit(200)
30 | emit(300)
31 | // throw RuntimeException("Exception from catch()")
32 | }/*.onEach { throw RuntimeException("Exception from onEach()") }
33 | .catch { println("catch() 2: $it") }*/
34 | scope.launch {
35 | try {
36 | flow1.collect {
37 | /*val contributors = unstableGitHub.contributors("square", "retrofit")
38 | println("Contributors: $contributors")*/
39 | println("Data: $it")
40 | }
41 | } catch (e: TimeoutException) {
42 | println("Network error: $e")
43 | }
44 | }
45 | delay(10000)
46 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/31_MutableSharedFlow.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.cancel
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.flow.MutableSharedFlow
7 | import kotlinx.coroutines.flow.SharingStarted
8 | import kotlinx.coroutines.flow.asSharedFlow
9 | import kotlinx.coroutines.flow.flow
10 | import kotlinx.coroutines.flow.shareIn
11 | import kotlinx.coroutines.launch
12 | import kotlinx.coroutines.runBlocking
13 | import kotlin.coroutines.EmptyCoroutineContext
14 |
15 | fun main() = runBlocking {
16 | val scope = CoroutineScope(EmptyCoroutineContext)
17 | val flow1 = flow {
18 | emit(1)
19 | delay(1000)
20 | emit(2)
21 | delay(1000)
22 | emit(3)
23 | }
24 | val clickFlow = MutableSharedFlow()
25 | val readonlyClickFlow = clickFlow.asSharedFlow()
26 | val sharedFlow = flow1.shareIn(scope, SharingStarted.WhileSubscribed(), 2)
27 | scope.launch {
28 | clickFlow.emit("Hello")
29 | delay(1000)
30 | clickFlow.emit("Hi")
31 | delay(1000)
32 | clickFlow.emit("你好")
33 | val parent = this
34 | launch {
35 | delay(4000)
36 | parent.cancel()
37 | }
38 | delay(1500)
39 | sharedFlow.collect {
40 | println("SharedFlow in Coroutine 1: $it")
41 | }
42 | }
43 | scope.launch {
44 | delay(5000)
45 | sharedFlow.collect {
46 | println("SharedFlow in Coroutine 2: $it")
47 | }
48 | }
49 | delay(10000)
50 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_1_basics/7_de_magic.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._1_basics
2 |
3 | import android.os.Bundle
4 | import android.os.Handler
5 | import android.os.HandlerThread
6 | import android.os.Looper
7 | import android.widget.TextView
8 | import androidx.activity.ComponentActivity
9 | import androidx.lifecycle.lifecycleScope
10 | import com.rengwuxian.coursecoroutines.R
11 | import com.rengwuxian.coursecoroutines.common.Contributor
12 | import com.rengwuxian.coursecoroutines.common.gitHub
13 | import kotlinx.coroutines.launch
14 | import kotlin.concurrent.thread
15 |
16 | class DeMagicActivity : ComponentActivity() {
17 | private lateinit var infoTextView: TextView
18 |
19 | override fun onCreate(savedInstanceState: Bundle?) {
20 | super.onCreate(savedInstanceState)
21 | setContentView(R.layout.layout_1)
22 | infoTextView = findViewById(R.id.infoTextView)
23 |
24 | lifecycleScope.launch {
25 | // switchToBackground {
26 | // gitHub.contributors("square", "retrofit")
27 | // switchToMain {
28 | // showContributors(contributors)
29 | // }
30 | // }
31 | }
32 | }
33 |
34 | private fun coroutinesStyle() = lifecycleScope.launch {
35 | val contributors = gitHub.contributors("square", "retrofit")
36 | showContributors(contributors)
37 | }
38 |
39 | private fun showContributors(contributors: List) = contributors
40 | .map { "${it.login} (${it.contributions})" }
41 | .reduce { acc, s -> "$acc\n$s" }
42 | .let { infoTextView.text = it }
43 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_2_structured_concurrency/8_exception.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._2_structured_concurrency
2 |
3 | import kotlinx.coroutines.CancellationException
4 | import kotlinx.coroutines.CoroutineExceptionHandler
5 | import kotlinx.coroutines.CoroutineScope
6 | import kotlinx.coroutines.Job
7 | import kotlinx.coroutines.SupervisorJob
8 | import kotlinx.coroutines.delay
9 | import kotlinx.coroutines.launch
10 | import kotlinx.coroutines.runBlocking
11 | import kotlin.concurrent.thread
12 | import kotlin.coroutines.EmptyCoroutineContext
13 |
14 | fun main() = runBlocking {
15 | val scope = CoroutineScope(EmptyCoroutineContext)
16 | var childJob: Job? = null
17 | val parentJob = scope.launch {
18 | childJob = launch {
19 | launch {
20 | println("Grand child started")
21 | delay(3000)
22 | println("Grand child done")
23 | }
24 | delay(1000)
25 | throw IllegalStateException("User invalid!")
26 | }
27 | println("Parent started")
28 | delay(3000)
29 | println("Parent done")
30 | }
31 | delay(500)
32 | // CoroutineExceptionHandler
33 | // parentJob.cancel()
34 | // println("isActive: parent - ${parentJob.isActive}, child - ${childJob?.isActive}")
35 | // println("isCancelled: parent - ${parentJob.isCancelled}, child - ${childJob?.isCancelled}")
36 | // delay(1000)
37 | // println("isActive: parent - ${parentJob.isActive}, child - ${childJob?.isActive}")
38 | // println("isCancelled: parent - ${parentJob.isCancelled}, child - ${childJob?.isCancelled}")
39 | delay(10000)
40 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/16_transform.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.collect
6 | import kotlinx.coroutines.flow.flow
7 | import kotlinx.coroutines.flow.flowOf
8 | import kotlinx.coroutines.flow.map
9 | import kotlinx.coroutines.flow.mapNotNull
10 | import kotlinx.coroutines.flow.transform
11 | import kotlinx.coroutines.flow.transformLatest
12 | import kotlinx.coroutines.flow.transformWhile
13 | import kotlinx.coroutines.launch
14 | import kotlinx.coroutines.runBlocking
15 | import kotlin.coroutines.EmptyCoroutineContext
16 |
17 | fun main() = runBlocking {
18 | val scope = CoroutineScope(EmptyCoroutineContext)
19 | val flow1 = flowOf(1, 2, 3, 4, 5)
20 | val flow2 = flow {
21 | delay(100)
22 | emit(1)
23 | delay(100)
24 | emit(2)
25 | delay(100)
26 | emit(3)
27 | }
28 | scope.launch {
29 | flow1.transform {
30 | if (it > 0) {
31 | repeat(it) { _ ->
32 | emit("$it - hahaha")
33 | }
34 | }
35 | }.collect { println("1: $it") }
36 | flow1.transformWhile {
37 | if (it > 3) return@transformWhile false
38 | if (it > 0) {
39 | repeat(it) { _ ->
40 | emit("$it - hahaha")
41 | }
42 | }
43 | true
44 | }.collect { println("2: $it") }
45 | flow2.transformLatest {
46 | delay(50)
47 | emit("$it - start")
48 | delay(100)
49 | emit("$it - end")
50 | }.collect { println("3: $it") }
51 | }
52 | delay(10000)
53 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/13_timeout_sample_debounce.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.FlowPreview
5 | import kotlinx.coroutines.TimeoutCancellationException
6 | import kotlinx.coroutines.delay
7 | import kotlinx.coroutines.flow.Flow
8 | import kotlinx.coroutines.flow.collect
9 | import kotlinx.coroutines.flow.debounce
10 | import kotlinx.coroutines.flow.flow
11 | import kotlinx.coroutines.flow.flowOf
12 | import kotlinx.coroutines.flow.sample
13 | import kotlinx.coroutines.flow.timeout
14 | import kotlinx.coroutines.launch
15 | import kotlinx.coroutines.runBlocking
16 | import kotlin.coroutines.EmptyCoroutineContext
17 | import kotlin.time.Duration
18 | import kotlin.time.Duration.Companion.seconds
19 |
20 | @OptIn(FlowPreview::class)
21 | fun main() = runBlocking {
22 | val scope = CoroutineScope(EmptyCoroutineContext)
23 | val flow1 = flow {
24 | emit(0)
25 | delay(500)
26 | emit(1)
27 | delay(800)
28 | emit(2)
29 | delay(900)
30 | emit(3)
31 | delay(1000)
32 | }
33 | scope.launch {
34 | // flow1.timeout(1.seconds).collect { println("1: $it") }
35 | // flow1.sample(1.seconds).collect { println("2: $it") }
36 | flow1.debounce(1.seconds).collect { println("3: $it") }
37 | }
38 | delay(10000)
39 | }
40 |
41 | fun Flow.throttle(timeWindow: Duration): Flow = flow {
42 | var lastTime = 0L
43 | collect {
44 | if (System.currentTimeMillis() - lastTime > timeWindow.inWholeMilliseconds) {
45 | emit(it)
46 | lastTime = System.currentTimeMillis()
47 | }
48 | }
49 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_5_collaboration/2_select.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._5_collaboration
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.ExperimentalCoroutinesApi
5 | import kotlinx.coroutines.async
6 | import kotlinx.coroutines.channels.Channel
7 | import kotlinx.coroutines.delay
8 | import kotlinx.coroutines.launch
9 | import kotlinx.coroutines.runBlocking
10 | import kotlinx.coroutines.selects.onTimeout
11 | import kotlinx.coroutines.selects.select
12 | import kotlin.coroutines.EmptyCoroutineContext
13 | import kotlin.time.Duration.Companion.seconds
14 |
15 | @OptIn(ExperimentalCoroutinesApi::class)
16 | fun main() = runBlocking {
17 | val scope = CoroutineScope(EmptyCoroutineContext)
18 | val job1 = launch {
19 | delay(1000)
20 | println("job1 done")
21 | }
22 | val job2 = launch {
23 | delay(2000)
24 | println("job2 done")
25 | }
26 | val deferred = async {
27 | delay(500)
28 | "rengwuxian"
29 | }
30 | val channel = Channel()
31 | scope.launch {
32 | val result = select {
33 | job1.onJoin {
34 | delay(2000)
35 | 1
36 | }
37 | job2.onJoin {
38 | 2
39 | }
40 | deferred.onAwait {
41 | it
42 | }
43 | channel.onSend("haha") {
44 |
45 | }
46 | /* channel 的 onSend()、onReceive()、onReceiveCatching() 只能选其一，不能同时应用
47 | channel.onReceive {
48 |
49 | }
50 | channel.onReceiveCatching {
51 |
52 | }
53 | */
54 | onTimeout(1.seconds) {
55 |
56 | }
57 | }
58 | println("Result: $result")
59 | }
60 | delay(10000)
61 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_1_basics/3_android.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._1_basics
2 |
3 | import android.os.Bundle
4 | import android.widget.TextView
5 | import androidx.activity.ComponentActivity
6 | import androidx.lifecycle.ViewModel
7 | import androidx.lifecycle.lifecycleScope
8 | import androidx.lifecycle.viewModelScope
9 | import com.rengwuxian.coursecoroutines.R
10 | import com.rengwuxian.coursecoroutines.common.Contributor
11 | import com.rengwuxian.coursecoroutines.common.gitHub
12 | import kotlinx.coroutines.CoroutineScope
13 | import kotlinx.coroutines.Dispatchers
14 | import kotlinx.coroutines.launch
15 |
16 | class AndroidActivity : ComponentActivity() {
17 | private lateinit var infoTextView: TextView
18 |
19 | override fun onCreate(savedInstanceState: Bundle?) {
20 | super.onCreate(savedInstanceState)
21 | setContentView(R.layout.layout_1)
22 | infoTextView = findViewById(R.id.infoTextView)
23 |
24 | // KTX
25 | lifecycleScope.launch {
26 |
27 | }
28 | // ContinuationInterceptor
29 | Dispatchers.Default
30 | // Handler.post()
31 | }
32 |
33 | class MyViewModel : ViewModel() {
34 | fun someFun() {
35 | viewModelScope.launch {
36 |
37 | }
38 | }
39 | }
40 |
41 | private fun coroutinesStyle() = lifecycleScope.launch {
42 | val contributors = gitHub.contributors("square", "retrofit")
43 | showContributors(contributors)
44 | }
45 |
46 | private fun showContributors(contributors: List) = contributors
47 | .map { "${it.login} (${it.contributions})" }
48 | .reduce { acc, s -> "$acc\n$s" }
49 | .let { infoTextView.text = it }
50 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_1_basics/4_withContext.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._1_basics
2 |
3 | import android.os.Bundle
4 | import android.widget.TextView
5 | import androidx.activity.ComponentActivity
6 | import androidx.lifecycle.lifecycleScope
7 | import com.rengwuxian.coursecoroutines.R
8 | import com.rengwuxian.coursecoroutines.common.Contributor
9 | import com.rengwuxian.coursecoroutines.common.gitHub
10 | import kotlinx.coroutines.CoroutineScope
11 | import kotlinx.coroutines.Dispatchers
12 | import kotlinx.coroutines.launch
13 | import kotlinx.coroutines.withContext
14 |
15 | class WithContextActivity : ComponentActivity() {
16 | private lateinit var infoTextView: TextView
17 |
18 | override fun onCreate(savedInstanceState: Bundle?) {
19 | super.onCreate(savedInstanceState)
20 | setContentView(R.layout.layout_1)
21 | infoTextView = findViewById(R.id.infoTextView)
22 |
23 |
24 | CoroutineScope(Dispatchers.Main).launch {
25 | val data = withContext(Dispatchers.IO) {
26 | // 网络代码
27 | "data"
28 | }
29 | val processedData = withContext(Dispatchers.Default) {
30 | // 处理数据
31 | "processed $data"
32 | }
33 | println("Processed data: $processedData")
34 | }
35 | }
36 |
37 | private fun coroutinesStyle() = lifecycleScope.launch {
38 | val contributors = gitHub.contributors("square", "retrofit")
39 | showContributors(contributors)
40 | }
41 |
42 | private fun showContributors(contributors: List) = contributors
43 | .map { "${it.login} (${it.contributions})" }
44 | .reduce { acc, s -> "$acc\n$s" }
45 | .let { infoTextView.text = it }
46 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_5_collaboration/Java.java:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._5_collaboration;
2 |
3 | import java.util.concurrent.Semaphore;
4 | import java.util.concurrent.locks.ReentrantLock;
5 |
6 | public class Java {
7 | int number = 0;
8 | // final Object lock = new Object();
9 | ReentrantLock lock = new ReentrantLock();
10 | Semaphore semaphore = new Semaphore(3);
11 | Object waiter = new Object();
12 | volatile int v = 0;
13 | transient int t = 0;
14 |
15 | synchronized void synchronizedMethod() {
16 | try {
17 | waiter.wait();
18 | waiter.notify();
19 | waiter.notifyAll();
20 | } catch (InterruptedException e) {
21 | throw new RuntimeException(e);
22 | }
23 | try {
24 | semaphore.acquire();
25 | } catch (InterruptedException e) {
26 | throw new RuntimeException(e);
27 | } finally {
28 | semaphore.release();
29 | }
30 | lock.lock();
31 | try {
32 | lock.lock();
33 | try {
34 | number++;
35 | } finally {
36 | lock.unlock();
37 | }
38 | } finally {
39 | lock.unlock();
40 | }
41 | }
42 |
43 | void synchronizedMethod2() {
44 | synchronized (this) {
45 | number--;
46 | }
47 | }
48 |
49 | ThreadLocal localString = new ThreadLocal<>();
50 | String directString;
51 |
52 | void threadLocal() {
53 | String string = localString.get();
54 | localString.set("rengwuxian");
55 | String string1 = directString;
56 | directString = "扔物线";
57 |
58 | new Thread() {
59 | @Override
60 | public void run() {
61 | String innerString = localString.get();
62 | }
63 | }.start();
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_5_collaboration/3_mutex.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._5_collaboration
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.launch
6 | import kotlinx.coroutines.runBlocking
7 | import kotlinx.coroutines.sync.Mutex
8 | import kotlinx.coroutines.sync.Semaphore
9 | import kotlinx.coroutines.sync.withLock
10 | import java.util.concurrent.CopyOnWriteArrayList
11 | import java.util.concurrent.atomic.AtomicInteger
12 | import kotlin.concurrent.thread
13 | import kotlin.coroutines.EmptyCoroutineContext
14 |
15 | //@Synchronized
16 | fun main() = runBlocking {
17 | var number = 0
18 | val lock = Any()
19 | /*val thread1 = thread {
20 | repeat(100_0000) {
21 | synchronized(lock) {
22 | number++
23 | }
24 | }
25 | }
26 | val thread2 = thread {
27 | repeat(100_0000) {
28 | synchronized(lock) {
29 | number--
30 | }
31 | }
32 | }
33 | thread1.join()
34 | thread2.join()
35 | println("number: $number")*/
36 | val scope = CoroutineScope(EmptyCoroutineContext)
37 | val mutex = Mutex() // mutual exclusion
38 | val semaphore = Semaphore(3)
39 | AtomicInteger()
40 | CopyOnWriteArrayList()
41 | val job1 = scope.launch {
42 | semaphore.acquire()
43 | semaphore.release()
44 | repeat(100_0000) {
45 | mutex.withLock {
46 | number++
47 | }
48 | }
49 | }
50 | val job2 = scope.launch {
51 | repeat(100_0000) {
52 | mutex.withLock {
53 | number--
54 | }
55 | }
56 | }
57 | job1.join()
58 | job2.join()
59 | println("number: $number")
60 | delay(10000)
61 | }
62 |
63 | @Volatile var v = 0
64 | @Transient var t = 0
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/21_try_catch.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import com.rengwuxian.coursecoroutines.common.unstableGitHub
4 | import kotlinx.coroutines.CoroutineScope
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.flow.flow
7 | import kotlinx.coroutines.flow.map
8 | import kotlinx.coroutines.flow.onEach
9 | import kotlinx.coroutines.flow.transform
10 | import kotlinx.coroutines.launch
11 | import kotlinx.coroutines.runBlocking
12 | import java.util.concurrent.TimeoutException
13 | import kotlin.coroutines.EmptyCoroutineContext
14 |
15 | fun main() = runBlocking {
16 | val scope = CoroutineScope(EmptyCoroutineContext)
17 | val flow1 = flow {
18 | try {
19 | for (i in 1..5) {
20 | // 数据库读数据
21 | // 网络请求
22 | emit(i)
23 | }
24 | } catch (e: Exception) {
25 | println("Error in flow(): $e")
26 | throw e
27 | }
28 | }.map { throw NullPointerException() }
29 | .onEach { throw NullPointerException() }
30 | .transform {
31 | val data = it * 2
32 | emit(data)
33 | emit(data)
34 | }
35 | // Exception Transparency
36 | scope.launch {
37 | try {
38 | flow1.collect {
39 | val contributors = unstableGitHub.contributors("square", "retrofit")
40 | println("Contributors: $contributors")
41 | }
42 | } catch (e: TimeoutException) {
43 | println("Network error: $e")
44 | } catch (e: NullPointerException) {
45 | println("Null data: $e")
46 | }
47 | }
48 | delay(10000)
49 | }
50 |
51 | private fun fun1() {
52 | fun2()
53 | }
54 |
55 | private fun fun2() {
56 | fun3()
57 | }
58 |
59 | private fun fun3() {
60 | throw NullPointerException("User null")
61 | }
62 |
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_5_collaboration/1_collaboration.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._5_collaboration
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.async
5 | import kotlinx.coroutines.channels.Channel
6 | import kotlinx.coroutines.delay
7 | import kotlinx.coroutines.launch
8 | import kotlinx.coroutines.runBlocking
9 | import java.util.concurrent.CountDownLatch
10 | import kotlin.concurrent.thread
11 | import kotlin.coroutines.EmptyCoroutineContext
12 |
13 | fun main() = runBlocking {
14 | val scope = CoroutineScope(EmptyCoroutineContext)
15 | val latch = CountDownLatch(2)
16 | thread {
17 | latch.await()
18 | //
19 | }
20 | thread {
21 | Thread.sleep(1000)
22 | latch.countDown()
23 | }
24 | thread {
25 | Thread.sleep(2000)
26 | latch.countDown()
27 | }
28 | val preJob1 = launch {
29 | delay(1000)
30 | }
31 | val preJob2 = launch {
32 | delay(2000)
33 | }
34 | launch {
35 | preJob1.join()
36 | preJob2.join()
37 | }
38 | val channel = Channel(2)
39 | launch {
40 | repeat(2) {
41 | channel.receive()
42 | }
43 | }
44 | launch {
45 | delay(1000)
46 | channel.send(Unit)
47 | }
48 | launch {
49 | delay(2000)
50 | channel.send(Unit)
51 | }
52 | val job1 = scope.launch {
53 | println("Job 1 started")
54 | delay(2000)
55 | println("Job 1 done")
56 | }
57 | val deferred = scope.async {
58 | println("Deferred started")
59 | delay(3000)
60 | println("Deferred done")
61 | "rengwuxian"
62 | }
63 | scope.launch {
64 | println("Job 2 started")
65 | delay(1000)
66 | job1.join()
67 | println("Deferred result: ${deferred.await()}")
68 | println("Job 2 done")
69 | }
70 | delay(10000)
71 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/28_convert.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.count
6 | import kotlinx.coroutines.flow.first
7 | import kotlinx.coroutines.flow.firstOrNull
8 | import kotlinx.coroutines.flow.flowOf
9 | import kotlinx.coroutines.flow.last
10 | import kotlinx.coroutines.flow.lastOrNull
11 | import kotlinx.coroutines.flow.produceIn
12 | import kotlinx.coroutines.flow.single
13 | import kotlinx.coroutines.flow.singleOrNull
14 | import kotlinx.coroutines.flow.toCollection
15 | import kotlinx.coroutines.flow.toList
16 | import kotlinx.coroutines.flow.toSet
17 | import kotlinx.coroutines.launch
18 | import kotlinx.coroutines.runBlocking
19 | import kotlin.coroutines.EmptyCoroutineContext
20 |
21 | fun main() = runBlocking {
22 | val scope = CoroutineScope(EmptyCoroutineContext)
23 | val flow1 = flowOf(1, 2, 3, 4, 5)
24 | val channel = flow1.produceIn(scope) // Channel produce()
25 | scope.launch {
26 | println("First: ${flow1.first()}")
27 | println("First with condition: ${flow1.first { it > 2 }}")
28 | try {
29 | flowOf().first()
30 | } catch (e: NoSuchElementException) {
31 | println("No element")
32 | }
33 | println("firstOrNull(): ${flow1.firstOrNull { it > 5 }}")
34 | // terminal operator
35 | flow1.last()
36 | flow1.lastOrNull()
37 | try {
38 | flow1.single()
39 | } catch (e: Exception) {
40 |
41 | }
42 | flow1.singleOrNull()
43 | println("count(): ${flow1.count { it > 2 }}")
44 | val list = mutableListOf()
45 | println("List: ${flow1.toList(list)}")
46 | flow1.toSet() // Set
47 | flow1.toCollection(list)
48 | }
49 | delay(10000)
50 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/rengwuxian/coursecoroutines/_4_flow/18_reduce_fold.kt:
--------------------------------------------------------------------------------
1 | package com.rengwuxian.coursecoroutines._4_flow
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.flow.collect
6 | import kotlinx.coroutines.flow.flowOf
7 | import kotlinx.coroutines.flow.fold
8 | import kotlinx.coroutines.flow.reduce
9 | import kotlinx.coroutines.flow.runningFold
10 | import kotlinx.coroutines.flow.runningReduce
11 | import kotlinx.coroutines.flow.scan
12 | import kotlinx.coroutines.launch
13 | import kotlinx.coroutines.runBlocking
14 | import kotlin.coroutines.EmptyCoroutineContext
15 |
16 | fun main() = runBlocking {
17 | val scope = CoroutineScope(EmptyCoroutineContext)
18 | val flow1 = flowOf(1, 2, 3, 4, 5)
19 | val list = listOf(1, 2, 3, 4, 5)
20 | list.reduce { acc, i -> acc + i }.let { println("List reduced to $it") }
21 | list.runningReduce { acc, i -> acc + i }.let { println("New List: $it") }
22 | list.fold(10) { acc, i -> acc + i }.let { println("List folded to $it") }
23 | list.fold("ha") { acc, i -> "$acc - $i" }.let { println("List folded to string: $it") }
24 | list.runningFold("ha") { acc, i -> "$acc - $i" }.let { println("New String List: $it") }
25 | scope.launch {
26 | val sum = flow1.reduce { accumulator, value -> accumulator + value }
27 | println("Sum is $sum")
28 | flow1.runningReduce { accumulator, value -> accumulator + value }
29 | .collect { println("runningReduce: $it") }
30 | flow1.fold("ha") { acc, i -> "$acc - $i" }.let { println("Flow folded to string: $it") }
31 | flow1.runningFold("ha") { acc, i -> "$acc - $i" }
32 | .collect { println("Flow.runningFold(): $it") }
33 | flow1.scan("ha") { acc, i -> "$acc - $i" }
34 | .collect { println("Flow.scan(): $it") }
35 | }
36 | delay(10000)
37 | }
--------------------------------------------------------------------------------
/app/src/main/res/drawable/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
1 |
7 |
8 |
9 |
15 |