Coroutines source code of Youtube videos

Author: smartherd

src/60_thread_example.kt

@@ -0,0 +1,14 @@
+import kotlin.concurrent.thread
+
+fun main() {        // Executes in main thread
+
+    println("Main program starts: ${Thread.currentThread().name}")
+
+    thread {    // creates a background thread (worker thread)
+        println("Fake work starts: ${Thread.currentThread().name}")
+        Thread.sleep(1000)      // Pretend doing some work... may be file upload
+        println("Fake work finished: ${Thread.currentThread().name}")
+    }
+
+    println("Main program ends: ${Thread.currentThread().name}")
+}

src/61_first_coroutine.kt

@@ -0,0 +1,17 @@
+import kotlinx.coroutines.*
+
+
+fun main() {        // Executes in main thread
+
+    println("Main program starts: ${Thread.currentThread().name}")
+
+    GlobalScope.launch {    // creates a background coroutine that runs on a background thread
+        println("Fake work starts: ${Thread.currentThread().name}")
+        Thread.sleep(1000)      // Pretend doing some work... may be file upload
+        println("Fake work finished: ${Thread.currentThread().name}")
+    }
+
+    // Blocks the current main thread & wait for coroutine to finish (practically not a right way to wait)
+    Thread.sleep(2000)
+    println("Main program ends: ${Thread.currentThread().name}")
+}

src/62_runBlocking_and_delay.kt

@@ -0,0 +1,17 @@
+import kotlinx.coroutines.*
+
+
+fun main() = runBlocking {        // Executes in main thread
+
+        println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+        GlobalScope.launch {    // Thread: T1
+            println("Fake work starts: ${Thread.currentThread().name}")     // Thread: T1
+            delay(1000)   // Coroutine is suspended but Thread: T1 is free (not blocked)
+            println("Fake work finished: ${Thread.currentThread().name}") // Either T1 or some other thread.
+        }
+
+        delay(2000)  // main thread: wait for coroutine to finish (practically not a right way to wait)
+
+        println("Main program ends: ${Thread.currentThread().name}")    // main thread
+}

src/63_custom_suspending_function.kt

@@ -0,0 +1,23 @@
+
+import kotlinx.coroutines.*
+
+
+fun main() = runBlocking {        // Executes in main thread
+
+        println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+        GlobalScope.launch {    // Thread: T1
+            println("Fake work starts: ${Thread.currentThread().name}")     // Thread: T1
+            mySuspendFunc(1000)   // Coroutine is suspended but Thread: T1 is free (not blocked)
+            println("Fake work finished: ${Thread.currentThread().name}") // Either T1 or some other thread.
+        }
+
+        mySuspendFunc(2000)  // main thread: wait for coroutine to finish (practically not a right way to wait)
+
+        println("Main program ends: ${Thread.currentThread().name}")    // main thread
+}
+
+suspend fun mySuspendFunc(time: Long) {
+    // code..
+    delay(time)
+}

src/64_launch_coroutine_builder.kt

@@ -0,0 +1,17 @@
+import kotlinx.coroutines.*
+
+
+fun main() = runBlocking {    // Creates a blocking coroutine that executes in current thread (main)
+
+    println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+    val job: Job = launch {   // Thread: main
+        println("Fake work starts: ${Thread.currentThread().name}")     // Thread: main
+        delay(1000)   // Coroutine is suspended but Thread: main is free (not blocked)
+        println("Fake work finished: ${Thread.currentThread().name}") // Thread: main
+    }
+
+    job.join()      // main thread: wait for coroutine to finish 
+
+    println("Main program ends: ${Thread.currentThread().name}")    // main thread
+}

src/65_async_coroutine_builder.kt

@@ -0,0 +1,18 @@
+import kotlinx.coroutines.*
+
+
+fun main() = runBlocking {    // Creates a blocking coroutine that executes in current thread (main)
+
+    println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+    val deferredJob: Deferred<Unit> = async   // Thread: main
+        println("Fake work starts: ${Thread.currentThread().name}")     // Thread: main
+        delay(1000)   // Coroutine is suspended but Thread: main is free (not blocked)
+        println("Fake work finished: ${Thread.currentThread().name}") // Thread: main
+        15
+    }
+
+    val num: Int = deferredJob.await()  // main thread: wait for coroutine to finish and return data 
+
+    println("Main program ends: ${Thread.currentThread().name}")    // main thread
+}

src/66_a_runBlocking_coroutine_builder.kt

@@ -0,0 +1,22 @@
+import kotlinx.coroutines.*
+
+
+fun main() = runBlocking {    // Creates a blocking coroutine that executes in current thread (main)
+
+    println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+    val deferredJob: Deferred<Unit> = async   // Thread: main
+        println("Fake work starts: ${Thread.currentThread().name}")     // Thread: main
+        delay(1000)   // Coroutine is suspended but Thread: main is free (not blocked)
+        println("Fake work finished: ${Thread.currentThread().name}") // Thread: main
+        15
+    }
+
+    val num: Int = deferredJob.await()  // main thread: wait for coroutine to finish and return data 
+
+    println("Main program ends: ${Thread.currentThread().name}")    // main thread
+}
+
+suspend fun myOwnSuspendingFunc() {
+    delay(1000)     // do something
+}

src/66_b_test_case.kt

@@ -0,0 +1,12 @@
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert
+import org.junit.Test
+
+class SimpleTest {
+
+    @Test
+    fun myFirstTest() = runBlocking {
+        myOwnSuspendingFunc()
+        Assert.assertEquals(10, 5 + 5)
+    }
+}

src/68_cooperative_coroutine_suspend_function.kt

@@ -0,0 +1,18 @@
+import kotlinx.coroutines.*
+
+fun main() = runBlocking {    // Creates a blocking coroutine that executes in current thread (main)
+
+    println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+    val job: Job = launch {     // Thread T1: Creates a non-blocking coroutine
+        for (i in 0..500) {
+            print("$i.")
+            yield()     // or use delay() or any other suspending function as per your need.
+        }
+    }
+
+    delay(10)  // Let's print a few values before we cancel
+    job.cancelAndJoin()
+
+    println("\nMain program ends: ${Thread.currentThread().name}")    // main thread
+}

src/69_isActive_flag_cooperative_coroutine.kt

@@ -0,0 +1,21 @@
+import kotlinx.coroutines.*
+
+fun main() = runBlocking {    // Creates a blocking coroutine that executes in current thread (main)
+
+    println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+    val job: Job = launch(Dispatchers.Default) {     // Thread T1: Creates a non-blocking coroutine
+        for (i in 0..500) {
+            if (!isActive) {
+                return@launch // break
+            }
+            print("$i.")
+            Thread.sleep(1)
+        }
+    }
+
+    delay(10)  // Let's print a few values before we cancel
+    job.cancelAndJoin()
+
+    println("\nMain program ends: ${Thread.currentThread().name}")    // main thread
+}

src/70_exception_handling.kt

@@ -0,0 +1,25 @@
+import kotlinx.coroutines.*
+
+fun main() = runBlocking {    // Creates a blocking coroutine that executes in current thread (main)
+
+    println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+    val job: Job = launch(Dispatchers.Default) {     // Thread T1: Creates a non-blocking coroutine
+        try {
+            for (i in 0..500) {
+                print("$i.")
+                delay(5)    // or use yield() or any other suspending function as per your need.
+            }
+        } catch (ex: CancellationException) {
+            print("\nException caught safely: ${ex.message}")
+        } finally {
+            print("\nClose resources in finally")
+        }
+    }
+
+    delay(10)  // Let's print a few values before we cancel
+    job.cancel(CancellationException("My own crash message"))
+    job.join()
+
+    println("\nMain program ends: ${Thread.currentThread().name}")    // main thread
+}

src/71_withContext_coroutine_builder.kt

@@ -0,0 +1,28 @@
+import kotlinx.coroutines.*
+
+fun main() = runBlocking {    // Creates a blocking coroutine that executes in current thread (main)
+
+    println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+    val job: Job = launch(Dispatchers.Default) {     // Thread T1: Creates a non-blocking coroutine
+        try {
+            for (i in 0..500) {
+                print("$i.")
+                delay(5)    // or use yield() or any other suspending function as per your need.
+            }
+        } catch (ex: CancellationException) {
+            print("\nException caught safely: ${ex.message}")
+        } finally {
+            withContext(NonCancellable) {
+                delay(1000)     // Generally we don't use suspending function in finally
+                print("\nClose resources in finally")
+            }
+        }
+    }
+
+    delay(10)  // Let's print a few values before we cancel
+    job.cancel(CancellationException("My own crash message"))
+    job.join()
+
+    println("\nMain program ends: ${Thread.currentThread().name}")    // main thread
+}

src/72_withTimeout_coroutine_builder.kt

@@ -0,0 +1,21 @@
+import kotlinx.coroutines.*
+
+fun main() = runBlocking {    // Creates a blocking coroutine that executes in current thread (main)
+
+    println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+    withTimeout(1300) {
+        try {
+            for (i in 0..1000) {
+                print("$i.")
+                delay(500)
+            }
+        } catch (ex: TimeoutCancellationException) {
+            // .. code..
+        } finally {
+            // .. code..
+        }
+    }
+
+    println("\nMain program ends: ${Thread.currentThread().name}")    // main thread
+}

src/73_withTimeoutOrNull_coroutine_builder.kt

@@ -0,0 +1,19 @@
+import kotlinx.coroutines.*
+
+fun main() = runBlocking {    // Creates a blocking coroutine that executes in current thread (main)
+
+    println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+    val result: String? = withTimeoutOrNull(2000) {
+        for (i in 0..500) {
+            print("$i.")
+            delay(500)
+        }
+
+        "I am done"
+    }
+
+    print("Result: $result")
+
+    println("\nMain program ends: ${Thread.currentThread().name}")    // main thread
+}

src/74_sequential_suspending_functions.kt

@@ -0,0 +1,27 @@
+import kotlinx.coroutines.*
+import kotlin.system.measureTimeMillis
+
+
+fun main() = runBlocking {    // Creates a blocking coroutine that executes in current thread (main)
+
+    println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+    val time = measureTimeMillis {
+        val msgOne = getMessageOne()
+        val msgTwo = getMessageTwo()
+        println("The entire message is: ${msgOne + msgTwo}")
+    }
+
+    println("Completed in $time ms")
+    println("Main program ends: ${Thread.currentThread().name}")    // main thread
+}
+
+suspend fun getMessageOne(): String {
+    delay(1000L)    // pretend to do some work
+    return "Hello "
+}
+
+suspend fun getMessageTwo(): String {
+    delay(1000L)    // pretend to do some work
+    return "World!"
+}

src/75_concurrency_within_coroutine.kt

@@ -0,0 +1,33 @@
+import kotlinx.coroutines.*
+import kotlin.system.measureTimeMillis
+
+
+fun main() = runBlocking {    // Creates a blocking coroutine that executes in current thread (main)
+
+    println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+    val time = measureTimeMillis {
+        val msgOne: Deferred<String> = async {
+            // ..more code..
+            getMessageOne()
+        }
+        val msgTwo: Deferred<String> = async {
+            // ..more code..
+            getMessageTwo()
+        }
+        println("The entire message is: ${msgOne.await() + msgTwo.await()}")
+    }
+
+    println("Completed in $time ms")
+    println("Main program ends: ${Thread.currentThread().name}")    // main thread
+}
+
+suspend fun getMessageOne(): String {
+    delay(1000L)    // pretend to do some work
+    return "Hello "
+}
+
+suspend fun getMessageTwo(): String {
+    delay(1000L)    // pretend to do some work
+    return "World!"
+}

src/76_lazy_async.kt

@@ -0,0 +1,25 @@
+
+import kotlinx.coroutines.*
+
+fun main() = runBlocking {    // Creates a blocking coroutine that executes in current thread (main)
+
+    println("Main program starts: ${Thread.currentThread().name}")  // main thread
+
+    val msgOne: Deferred<String> = async(start = CoroutineStart.LAZY) { getMessageOne() }
+    val msgTwo: Deferred<String> = async(start = CoroutineStart.LAZY) { getMessageTwo() }
+    println("The entire message is: ${msgOne.await() + msgTwo.await()}")
+
+    println("Main program ends: ${Thread.currentThread().name}")    // main thread
+}
+
+suspend fun getMessageOne(): String {
+    delay(1000L)    // pretend to do some work
+    println("After working in getMessageOne()")
+    return "Hello "
+}
+
+suspend fun getMessageTwo(): String {
+    delay(1000L)    // pretend to do some work
+    println("After working in getMessageTwo()")
+    return "World!"
+}