├── .gitignore
├── .idea
├── .gitignore
├── compiler.xml
├── deploymentTargetDropDown.xml
├── gradle.xml
├── misc.xml
└── vcs.xml
├── README.md
├── app
├── .gitignore
├── build.gradle
├── proguard-rules.pro
└── src
│ └── main
│ ├── AndroidManifest.xml
│ ├── java
│ └── com
│ │ └── halil
│ │ └── ozel
│ │ └── coroutines101
│ │ ├── CoroutineScopeClass.kt
│ │ ├── CoroutinesAsync.kt
│ │ ├── DispatchersCoroutines.kt
│ │ ├── GlobalScopeClass.kt
│ │ ├── MainActivity.kt
│ │ ├── NestedCoroutines.kt
│ │ ├── RunBlockingClass.kt
│ │ └── SuspendCoroutines.kt
│ └── res
│ ├── drawable-v24
│ └── ic_launcher_foreground.xml
│ ├── drawable
│ └── ic_launcher_background.xml
│ ├── layout
│ └── activity_main.xml
│ ├── mipmap-anydpi-v26
│ ├── ic_launcher.xml
│ └── ic_launcher_round.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
│ ├── values-night
│ └── themes.xml
│ └── values
│ ├── colors.xml
│ ├── strings.xml
│ └── themes.xml
├── build.gradle
├── gradle.properties
├── gradle
└── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
└── settings.gradle
/.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 |
--------------------------------------------------------------------------------
/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 |
--------------------------------------------------------------------------------
/.idea/compiler.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/.idea/deploymentTargetDropDown.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
--------------------------------------------------------------------------------
/.idea/gradle.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
18 |
19 |
--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Coroutines-101 🧵
2 |
3 | 
4 |
5 | A coroutine is a concurrency design pattern that you can use on Android to simplify code that executes asynchronously. Coroutines were added to Kotlin in version 1.3 and are based on established concepts from other languages.
6 |
7 | On Android, coroutines help to manage long-running tasks that might otherwise block the main thread and cause your app to become unresponsive. Over 50% of professional developers who use coroutines have reported seeing increased productivity. This topic describes how you can use Kotlin coroutines to address these problems, enabling you to write cleaner and more concise app code.
8 |
9 |
10 | ## Features 👀
11 |
12 | 
13 |
14 | Coroutines is our recommended solution for asynchronous programming on Android. Noteworthy features include the following:
15 |
16 | 1. **Lightweight**: You can run many coroutines on a single thread due to support for suspension, which doesn't block the thread where the coroutine is running. Suspending saves memory over blocking while supporting many concurrent operations.
17 | 2. **Fewer memory leaks**: Use structured concurrency to run operations within a scope.
18 | 3. **Built-in cancellation support**: Cancellation is propagated automatically through the running coroutine hierarchy.
19 | 4. **Jetpack integration**: Many Jetpack libraries include extensions that provide full coroutines support. Some libraries also provide their own coroutine scope that you can use for structured concurrency.
20 |
21 | ## Project Contents 📜
22 |
23 | - [CoroutineScope](https://github.com/halilozel1903/Coroutines101/blob/master/app/src/main/java/com/halil/ozel/coroutines101/CoroutineScopeClass.kt)
24 | - [Dispatchers Coroutines](https://github.com/halilozel1903/Coroutines101/blob/master/app/src/main/java/com/halil/ozel/coroutines101/DispatchersCoroutines.kt)
25 | - [GlobalScope](https://github.com/halilozel1903/Coroutines101/blob/master/app/src/main/java/com/halil/ozel/coroutines101/GlobalScopeClass.kt)
26 | - [Nested Coroutines](https://github.com/halilozel1903/Coroutines101/blob/master/app/src/main/java/com/halil/ozel/coroutines101/NestedCoroutines.kt)
27 | - [RunBlocking](https://github.com/halilozel1903/Coroutines101/blob/master/app/src/main/java/com/halil/ozel/coroutines101/RunBlockingClass.kt)
28 | - [Suspend Coroutines](https://github.com/halilozel1903/Coroutines101/blob/master/app/src/main/java/com/halil/ozel/coroutines101/SuspendCoroutines.kt)
29 | - [Coroutines Async](https://github.com/halilozel1903/Coroutines101/blob/master/app/src/main/java/com/halil/ozel/coroutines101/CoroutinesAsync.kt)
30 |
31 | ## Donation 💸
32 |
33 | If this project help 💁 you, Can you give me a cup of coffee? ☕
34 |
35 | [](https://www.buymeacoffee.com/halilozel1903)
36 |
37 | ## License ℹ️
38 | ```
39 | MIT License
40 |
41 | Copyright © 2022 Halil OZEL
42 |
43 | Permission is hereby granted, free of charge, to any person obtaining a copy
44 | of this software and associated documentation files (the "Software"), to deal
45 | in the Software without restriction, including without limitation the rights
46 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
47 | copies of the Software, and to permit persons to whom the Software is
48 | furnished to do so, subject to the following conditions:
49 |
50 | The above copyright notice and this permission notice shall be included in all
51 | copies or substantial portions of the Software.
52 |
53 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
54 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
55 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
56 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
57 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
58 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
59 | SOFTWARE.
60 | ```
61 |
--------------------------------------------------------------------------------
/app/.gitignore:
--------------------------------------------------------------------------------
1 | /build
--------------------------------------------------------------------------------
/app/build.gradle:
--------------------------------------------------------------------------------
1 | plugins {
2 | id 'com.android.application'
3 | id 'kotlin-android'
4 | }
5 |
6 | android {
7 | compileSdk 34
8 | defaultConfig {
9 | applicationId "com.halil.ozel.coroutines101"
10 | minSdk 24
11 | targetSdk 34
12 | versionCode 1
13 | versionName "1.0"
14 |
15 | testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
16 | }
17 |
18 | buildTypes {
19 | release {
20 | minifyEnabled false
21 | proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
22 | }
23 | }
24 | compileOptions {
25 | sourceCompatibility JavaVersion.VERSION_1_8
26 | targetCompatibility JavaVersion.VERSION_1_8
27 | }
28 | kotlinOptions {
29 | jvmTarget = '1.8'
30 | }
31 | namespace 'com.halil.ozel.coroutines101'
32 | }
33 |
34 | dependencies {
35 | implementation 'androidx.core:core-ktx:1.9.0'
36 | implementation 'androidx.appcompat:appcompat:1.6.1'
37 | implementation 'com.google.android.material:material:1.8.0'
38 | implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
39 | implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
40 | }
--------------------------------------------------------------------------------
/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/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
11 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
--------------------------------------------------------------------------------
/app/src/main/java/com/halil/ozel/coroutines101/CoroutineScopeClass.kt:
--------------------------------------------------------------------------------
1 | package com.halil.ozel.coroutines101
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.Dispatchers
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.launch
7 |
8 | class CoroutineScopeClass {
9 | fun main() {
10 | println("Coroutine Scope Start")
11 | CoroutineScope(Dispatchers.Default).launch {
12 | delay(4000)
13 | println("Coroutine Scope Continue")
14 | }
15 | println("Coroutine Scope End")
16 | }
17 | }
18 |
19 |
--------------------------------------------------------------------------------
/app/src/main/java/com/halil/ozel/coroutines101/CoroutinesAsync.kt:
--------------------------------------------------------------------------------
1 | package com.halil.ozel.coroutines101
2 |
3 | import kotlinx.coroutines.async
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.runBlocking
6 |
7 | /**
8 | * Created by halilozel1903 on 01.01.2022
9 | */
10 |
11 |
12 | fun main() {
13 | var url = ""
14 | var name = ""
15 |
16 | /**
17 | It is used for asynchronous operations that return a value.
18 | The difference from launch is that it returns Deffered instead of Job.
19 | The await() function is used to get the result.
20 | */
21 |
22 | runBlocking {
23 | val downloadedUrl = async { downloadUrl() }
24 | val downloadedName = async { downloadName() }
25 | url = downloadedUrl.await()
26 | name = downloadedName.await()
27 | println("$url -> $name")
28 | }
29 | }
30 |
31 | private suspend fun downloadUrl(): String {
32 | delay(3000)
33 | val url = "https://www.brooklyn99.com"
34 | println("Url was downloaded.")
35 | return url
36 | }
37 |
38 | private suspend fun downloadName(): String {
39 | delay(5000)
40 | val name = "Brooklyn Nine-Nine"
41 | println("Name was downloaded.")
42 | return name
43 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/halil/ozel/coroutines101/DispatchersCoroutines.kt:
--------------------------------------------------------------------------------
1 | package com.halil.ozel.coroutines101
2 |
3 | import kotlinx.coroutines.Dispatchers
4 | import kotlinx.coroutines.launch
5 | import kotlinx.coroutines.runBlocking
6 |
7 | class DispatchersCoroutines {
8 | fun main() {
9 |
10 | /**
11 | It is a mechanism that specifies which thread the coroutine will run on. There are 4 different types.
12 |
13 | Dispatchers.Default : Used for CPU operations. launch is the default dispatcher of the async standard
14 | coroutine creation functions.
15 |
16 | Dispatchers.IO : It is used for Network and Disk based jobs. It is frequently used in corporate applications.
17 |
18 | Dispatchers.Main : Works with Main Thread. UI thread operations are done.
19 |
20 | Dispatchers.Unconfined: Although it is used in Main Thread operations, it is a dispatcher that is not
21 | recommended to be used. It starts the coroutine process in the called thread.
22 | */
23 |
24 | runBlocking {
25 | launch(Dispatchers.Main) {
26 | println("Main Thread: ${Thread.currentThread().name}")
27 | }
28 | launch(Dispatchers.IO) {
29 | println("IO Thread: ${Thread.currentThread().name}")
30 | }
31 | launch(Dispatchers.Default) {
32 | println("Default Thread: ${Thread.currentThread().name}")
33 | }
34 | launch(Dispatchers.Unconfined) {
35 | println("Unconfined Thread: ${Thread.currentThread().name}")
36 | }
37 | }
38 | }
39 | }
40 |
41 |
--------------------------------------------------------------------------------
/app/src/main/java/com/halil/ozel/coroutines101/GlobalScopeClass.kt:
--------------------------------------------------------------------------------
1 | package com.halil.ozel.coroutines101
2 |
3 | import kotlinx.coroutines.DelicateCoroutinesApi
4 | import kotlinx.coroutines.GlobalScope
5 | import kotlinx.coroutines.delay
6 | import kotlinx.coroutines.launch
7 |
8 | // Marks declarations in the coroutines that are delicate —
9 | // they have limited use-case and shall be used with care in general code
10 | @DelicateCoroutinesApi
11 | fun main() {
12 | /**
13 | GlobalScope: The difference of GlobalScope from runBlocking is that it acts independently.
14 | The end of the thread it is in does not prevent it from running.
15 | */
16 |
17 | println("Global Scope Start")
18 | GlobalScope.launch {
19 | delay(4000)
20 | println("Global Scope Continue")
21 | }
22 | println("Global Scope End")
23 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/halil/ozel/coroutines101/MainActivity.kt:
--------------------------------------------------------------------------------
1 | package com.halil.ozel.coroutines101
2 |
3 | import android.os.Bundle
4 | import androidx.appcompat.app.AppCompatActivity
5 | import kotlinx.coroutines.DelicateCoroutinesApi
6 |
7 | @DelicateCoroutinesApi
8 | class MainActivity : AppCompatActivity() {
9 | override fun onCreate(savedInstanceState: Bundle?) {
10 | super.onCreate(savedInstanceState)
11 | setContentView(R.layout.activity_main)
12 | val dispatchersCoroutines = DispatchersCoroutines()
13 | dispatchersCoroutines.main()
14 | }
15 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/halil/ozel/coroutines101/NestedCoroutines.kt:
--------------------------------------------------------------------------------
1 | package com.halil.ozel.coroutines101
2 |
3 | import kotlinx.coroutines.coroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.launch
6 | import kotlinx.coroutines.runBlocking
7 |
8 | fun main() {
9 | runBlocking {
10 | launch {
11 | delay(4000)
12 | println("RunBlocking")
13 | }
14 |
15 | coroutineScope {
16 | launch {
17 | delay(2000)
18 | println("CoroutineScope")
19 | }
20 | }
21 | }
22 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/halil/ozel/coroutines101/RunBlockingClass.kt:
--------------------------------------------------------------------------------
1 | package com.halil.ozel.coroutines101
2 |
3 | import kotlinx.coroutines.delay
4 | import kotlinx.coroutines.launch
5 | import kotlinx.coroutines.runBlocking
6 |
7 | fun main() {
8 |
9 | /**
10 | runBlocking: It is used to start a new coroutine. The main thread is blocked until the related task is completed.
11 | */
12 |
13 | println("runBlocking Start")
14 | runBlocking {
15 | launch {
16 | delay(4000)
17 | println("runBlocking Continue")
18 | }
19 | }
20 | println("runBlocking End")
21 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/halil/ozel/coroutines101/SuspendCoroutines.kt:
--------------------------------------------------------------------------------
1 | package com.halil.ozel.coroutines101
2 |
3 | import kotlinx.coroutines.coroutineScope
4 | import kotlinx.coroutines.delay
5 | import kotlinx.coroutines.runBlocking
6 |
7 | fun main() {
8 | runBlocking {
9 | delay(2000)
10 | println("Run Blocking")
11 | myFunction()
12 | }
13 | }
14 |
15 | /**
16 | It allows the completion of operations without blocking the current running thread.
17 | Suspend; These are functions that can be restarted and stopped. These functions should be used in the coroutine.
18 | */
19 | suspend fun myFunction() {
20 | coroutineScope {
21 | delay(4000)
22 | println("Suspend Function")
23 | }
24 | }
--------------------------------------------------------------------------------
/app/src/main/res/drawable-v24/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
1 |
3 |
5 |
6 |
8 |