Added chapters 14 and 15

Author: sksamuel

Chapter14/async.kt

@@ -0,0 +1,15 @@
+import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+
+fun main() {
+  runBlocking {
+    val deferred = async {
+      println("Computing value")
+      delay(1000)
+      "result"
+    }
+    val result = deferred.await()
+    println("The result is $result")
+  }
+}

Chapter14/cancel_children.kt

@@ -0,0 +1,28 @@
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+
+fun main() {
+  suspend fun child1() {
+    println("Starting child 1")
+    delay(2000)
+    println("Completing child 1")
+  }
+  suspend fun child2() {
+    println("Starting child 2")
+    delay(1000)
+    throw RuntimeException("Boom")
+  }
+  try {
+    runBlocking {
+      launch {
+        child1()
+      }
+      launch {
+        child2()
+      }
+    }
+  } catch (e: Exception) {
+    println("Failed with ${e.message}")
+  }
+}

Chapter14/child_failure.kt

@@ -0,0 +1,28 @@
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+
+fun main() {
+  suspend fun child1() {
+    println("Starting child 1")
+    delay(2000)
+    println("Completing child 1")
+  }
+  suspend fun child2() {
+    println("Starting child 2")
+    delay(1000)
+    throw RuntimeException("Boom")
+  }
+  try {
+    runBlocking {
+      launch {
+        child1()
+      }
+      launch {
+        child2()
+      }
+    }
+  } catch (e: Exception) {
+    println("Failed with ${e.message}")
+  }
+}

Chapter14/concurrent_ecommerce.kt

@@ -0,0 +1,39 @@
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlin.system.measureTimeMillis
+
+fun main() {
+
+  suspend fun printShippingLabels() {
+    delay(3000)
+    println("After three seconds")
+  }
+
+  suspend fun processPayment() {
+    delay(2000)
+    println("Order after two seconds")
+  }
+
+  suspend fun sendEmails() {
+    delay(1000)
+    println("Payment after one second")
+  }
+
+  println("Starting")
+  val time = measureTimeMillis {
+    runBlocking {
+      launch {
+        printShippingLabels()
+      }
+      launch {
+        processPayment()
+      }
+      launch {
+        sendEmails()
+      }
+    }
+    println("runBlocking done")
+  }
+  println("Completed in $time ms")
+}

Chapter14/concurrent_ecommerce_async.kt

@@ -0,0 +1,39 @@
+import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlin.system.measureTimeMillis
+
+fun main() {
+
+  suspend fun fetchOrder(): String {
+    delay(3000)
+    return "Order 123"
+  }
+
+  suspend fun fetchAddress(): String {
+    delay(2000)
+    return "10 Downing Street"
+  }
+
+  suspend fun fetchUsername(): String {
+    delay(1000)
+    return "Prime Minster"
+  }
+
+  println("Starting")
+  val time = measureTimeMillis {
+    runBlocking {
+      val order = async {
+        fetchOrder()
+      }
+      val address = async {
+        fetchAddress()
+      }
+      val username = async {
+        fetchUsername()
+      }
+      println("Shipping ${order.await()} to ${username.await()} at ${address.await()}")
+    }
+  }
+  println("Completed in $time ms")
+}

Chapter14/debugging.kt

@@ -0,0 +1,20 @@
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+
+fun main() {
+  fun logger(message: String) = println("${Thread.currentThread().name} $message")
+  val jobs = (1..3).map {
+    GlobalScope.launch {
+      repeat(3) {
+        delay(300)
+        logger("I'm working hard")
+      }
+    }
+  }
+  runBlocking {
+    logger("Starting calculation")
+    jobs.forEach { it.join() }
+  }
+}

Chapter14/debugging_named.kt

@@ -0,0 +1,21 @@
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+
+fun main() {
+  fun logger(message: String) = println("${Thread.currentThread().name} $message")
+  val jobs = listOf("parser", "crawler", "lexer").map {
+    GlobalScope.launch(CoroutineName(it)) {
+      repeat(3) {
+        delay(300)
+        logger("I'm working hard")
+      }
+    }
+  }
+  runBlocking {
+    logger("Starting calculation")
+    jobs.forEach { it.join() }
+  }
+}

Chapter14/dispatcher_default.kt

@@ -0,0 +1,15 @@
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+
+fun main() {
+  runBlocking {
+    println("A: " + Thread.currentThread().name)
+    launch(Dispatchers.Default) {
+      println("B: " + Thread.currentThread().name)
+    }
+    launch {
+      println("C: " + Thread.currentThread().name)
+    }
+  }
+}

Chapter14/dispatcher_io.kt

@@ -0,0 +1,8 @@
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+
+fun main() {
+  runBlocking(Dispatchers.IO) {
+    println(Thread.currentThread().name)
+  }
+}

Chapter14/dispatcher_wrapper.kt

@@ -0,0 +1,17 @@
+import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import java.util.concurrent.Executors.newSingleThreadExecutor
+
+fun main() {
+  runBlocking {
+    val executor = newSingleThreadExecutor { r -> Thread(r, "my-executor-dispatcher") }
+    val dispatcher = executor.asCoroutineDispatcher()
+    launch(dispatcher) {
+      println(Thread.currentThread().name)
+    }
+    launch {
+      println(Thread.currentThread().name)
+    }
+  }
+}

Chapter14/exception_handler.kt

@@ -0,0 +1,26 @@
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+
+fun main() {
+  val handler = CoroutineExceptionHandler { context, throwable ->
+    println("Intercepted exception of type ${throwable.javaClass.simpleName}")
+  }
+  runBlocking {
+    val job = GlobalScope.launch(handler) {
+      launch {
+        println("Starting first child")
+        delay(1000)
+        println("First child completed")
+      }
+      launch {
+        println("Second child throwing exception")
+        delay(100)
+        throw IndexOutOfBoundsException()
+      }
+    }
+    job.join()
+  }
+}

Chapter14/exception_handler_await.kt

@@ -0,0 +1,16 @@
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
+
+fun main() {
+  val handler = CoroutineExceptionHandler { context, throwable ->
+    println("Intercepted exception of type ${throwable.javaClass.simpleName}")
+  }
+  runBlocking {
+    val deferred = GlobalScope.async(handler) {
+      throw IndexOutOfBoundsException()
+    }
+    deferred.await()
+  }
+}

Chapter14/first_coroutine.kt

@@ -0,0 +1,12 @@
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+fun main() {
+  GlobalScope.launch {
+    delay(1000)
+    println("I am a coroutine")
+  }
+  println("I am the main thread")
+  Thread.sleep(2000)
+}

Chapter14/intro.kt

@@ -0,0 +1,20 @@
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+fun main() {
+  GlobalScope.launch {
+    // create a new global level coroutine
+    delay(1000L) // wait for 1 second
+    println("World!")
+  }
+  println("Hello,") // main thread continues while coroutine is delayed
+  Thread.sleep(2000L) // block main thread to keep JVM alive
+  GlobalScope.launch(context = Dispatchers.IO) {
+    // will get dispatched to DefaultDispatcher
+    println("Default               : I'm working in thread ${Thread.currentThread().name}")
+  }
+
+
+}

Chapter14/jobs.kt

@@ -0,0 +1,19 @@
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+
+fun main() {
+  var x = 0
+  val job = GlobalScope.launch {
+    while (true) {
+      x += 1
+      delay(10)
+      println(x)
+    }
+  }
+  runBlocking {
+    delay(100)
+    job.cancel()
+  }
+}

Chapter14/join.kt

@@ -0,0 +1,15 @@
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+
+fun main() {
+  val job = GlobalScope.launch {
+    delay(1000L)
+    println("Hello")
+  }
+  runBlocking {
+    job.join()
+    println("World")
+  }
+}

Chapter14/lazy.kt

@@ -0,0 +1,17 @@
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+
+fun main() {
+  val job = GlobalScope.launch(start = CoroutineStart.LAZY) {
+    delay(100)
+    println("World")
+  }
+  runBlocking {
+    delay(1000)
+    println("Hello")
+    job.join()
+  }
+}