Chap07.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d7529e44-3ffe-4722-8604-b5fdfb050339",
   "metadata": {},
   "source": [
    "# 07. Corutines - a Lightweight Thread?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b9a19ab-0a82-4dc1-9d63-e0a519089b81",
   "metadata": {},
   "source": [
    "## What are corutines?\n",
    "교재가 집필되던 시절과 지금의 라이브러리 버전이 상당히 차이가 난다는 점에 유의!\n",
    "\n",
    "- https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/\n",
    "- https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.coroutines/\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b46d8e81-c7b0-4f74-926c-46b3b6d2eb6f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "// 라이브러리 가져오는데 약간의 시간이 걸림\n",
    "@file:DependsOn(\"org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.2\")\n",
    "import kotlinx.coroutines.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d1c0e254-a3eb-4036-9776-f6b24b14021e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DefaultDispatcher-worker-1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "StandaloneCoroutine{Active}@6348b9de"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GlobalScope.launch {\n",
    "    launch {\n",
    "        delay(500L)\n",
    "        println(\"after delay \" + Thread.currentThread().name)\n",
    "    }\n",
    "\n",
    "    println(Thread.currentThread().name)\n",
    "    Thread.currentThread().join()\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "50f3d07e-284f-4d63-8c97-47ceabe85baa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after delay DefaultDispatcher-worker-2\n",
      "DefaultDispatcher-worker-2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "StandaloneCoroutine{Active}@48bdcb5a"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GlobalScope.launch {\n",
    "    val job: Job = launch {\n",
    "        delay(500L)\n",
    "        println(\"after delay \" + Thread.currentThread().name)\n",
    "    }\n",
    "\n",
    "    println(Thread.currentThread().name)\n",
    "    job.cancel()\n",
    "    Thread.currentThread().join()\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2bdddae7-949e-4e85-93aa-b8bc5ced4207",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execution of code '/*여기?*/ runBlocking ...'\n",
      "after delay Execution of code '/*여기?*/ runBlocking ...'\n"
     ]
    }
   ],
   "source": [
    "/*여기?*/ runBlocking {\n",
    "    val job: Job = launch {\n",
    "        delay(500L)\n",
    "        println(\"after delay \" + Thread.currentThread().name)\n",
    "    }\n",
    "\n",
    "    println(Thread.currentThread().name)\n",
    "    job.join()\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0dd4007b-1dc3-4ee5-baa3-1246f52cae56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, \n",
      "coroutine!\n"
     ]
    }
   ],
   "source": [
    "/*저기?*/ runBlocking {\n",
    "    val job: Job = launch {\n",
    "        delay(500L)\n",
    "        println(\"coroutine!\")\n",
    "    }\n",
    "\n",
    "    println(\"Hello, \")\n",
    "    job.join()\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52b6c9f0-1b2d-4ee1-a4cc-5e3c18b07460",
   "metadata": {},
   "source": [
    "## Coroutines and threads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "adbc8440-963f-4050-987d-63cc14e098af",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DefaultDispatcher-worker-4\n",
      "DefaultDispatcher-worker-4\n",
      "DefaultDispatcher-worker-4\n",
      "DefaultDispatcher-worker-5\n",
      "DefaultDispatcher-worker-6\n",
      "DefaultDispatcher-worker-4\n",
      "DefaultDispatcher-worker-5\n",
      "DefaultDispatcher-worker-7\n",
      "DefaultDispatcher-worker-9\n",
      "DefaultDispatcher-worker-6\n",
      "DefaultDispatcher-worker-8\n",
      "DefaultDispatcher-worker-4\n",
      "DefaultDispatcher-worker-6\n",
      "DefaultDispatcher-worker-11\n",
      "DefaultDispatcher-worker-10\n",
      "DefaultDispatcher-worker-5\n",
      "DefaultDispatcher-worker-7\n",
      "DefaultDispatcher-worker-17\n",
      "DefaultDispatcher-worker-9\n",
      "DefaultDispatcher-worker-5\n",
      "DefaultDispatcher-worker-6\n",
      "DefaultDispatcher-worker-11\n",
      "DefaultDispatcher-worker-10\n",
      "DefaultDispatcher-worker-16\n",
      "DefaultDispatcher-worker-15"
     ]
    },
    {
     "data": {
      "text/plain": [
       "StandaloneCoroutine{Active}@4ccef44f"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "DefaultDispatcher-worker-14\n",
      "DefaultDispatcher-worker-13\n",
      "DefaultDispatcher-worker-8\n",
      "DefaultDispatcher-worker-12\n",
      "DefaultDispatcher-worker-4\n"
     ]
    }
   ],
   "source": [
    "GlobalScope.launch {\n",
    "    val parentJob = Job()\n",
    "    (1..30).forEach {\n",
    "        launch(context = parentJob) {\n",
    "            println( Thread.currentThread().name )\n",
    "        }\n",
    "    }\n",
    "    joinAll(parentJob)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e674a547-c8b6-472f-8b00-ba2b77184c57",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Runtime.getRuntime().availableProcessors()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c2043355-07ea-48d0-b979-b2cda97642ea",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "val parallelism = max(1, Runtime.getRuntime().availableProcessors() - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e457db60-d533-41bd-8c39-7d8e5a7a163f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n",
      "100\n",
      "300\n",
      "400\n",
      "600\n",
      "500\n",
      "900\n",
      "800\n",
      "700\n",
      "1100\n",
      "1000\n",
      "1200\n",
      "1300\n",
      "1500\n",
      "1400\n",
      "1700\n",
      "1600\n",
      "1900\n",
      "1800\n",
      "2200\n",
      "2300\n",
      "2100\n",
      "2000\n",
      "3000\n",
      "2900\n",
      "2800\n",
      "2700\n",
      "2600\n",
      "2500\n",
      "2400\n",
      "after: 3000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "StandaloneCoroutine{Completed}@6974471f"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var sum = 0\n",
    "// runBlocking { // single thread로 실행\n",
    "GlobalScope.launch { // multi thread로 실행\n",
    "    val parentJob = Job()\n",
    "    (1..30).forEach {\n",
    "        launch(context = parentJob) {\n",
    "            for (i in 1..100) sum += 1\n",
    "            val mysum = sum\n",
    "            delay(10)\n",
    "            println(mysum)\n",
    "        }\n",
    "    }\n",
    "    delay(20)\n",
    "    println(\"after: $sum\")\n",
    "    parentJob.children.forEach { it.join() }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c519bb5d-b0c7-44d8-a0ce-b29740f4ddc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "030b353b-238d-42c9-a3a1-8640a9c9a6da",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Coroutine examples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00a8b0d1-eabc-4720-81b1-174d7b3c0057",
   "metadata": {},
   "source": [
    "### Exception handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "21422db0-ca0e-494b-8a44-f4bc022a5466",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "999"
     ]
    },
    {
     "data": {
      "text/plain": [
       "StandaloneCoroutine{Completed}@196b5a88"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "suspend fun calculateValue() = withContext(context = Dispatchers.Default) { \n",
    "    // throw Exception() // 주석을 풀었다 걸었다 해보라\n",
    "    999\n",
    "}\n",
    "\n",
    "val defaultValue = 1\n",
    "\n",
    "runBlocking {\n",
    "    launch {\n",
    "        val result = try {\n",
    "            calculateValue()\n",
    "        } catch (exception: Exception) {\n",
    "            defaultValue\n",
    "        }\n",
    "        print(result)\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50207e15-dac0-4f0b-a166-e30c31e70d98",
   "metadata": {},
   "source": [
    "### Resource releasing\n",
    "코틀린이 문제가 아니라 Java 라이브리 자체가 버전이 올라가면서 바뀐 게 있어서 교재 코드는 작동안함\n",
    "\n",
    "참고로 Java에서 실제로는 보통 이럴 때 try-with-resources 라고 부르는 형식의 try문을 쓰도록 권장\n",
    "\n",
    "그리고 Kotin에서는 이런 경우 실제로 use라는 함수를 쓰도록 권장\n",
    "- https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.io/use.htmlhttps://kotlinlang.org/api/latest/jvm/stdlib/kotlin.io/use.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aea497d-00b9-4880-9232-69282ec9a176",
   "metadata": {},
   "source": [
    "### Non-cancelable block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "067f9916-5ac0-427d-998b-eb5def65713d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start\n",
      "kotlinx.coroutines.JobCancellationException: StandaloneCoroutine was cancelled; job=StandaloneCoroutine{Cancelling}@51778078\n"
     ]
    }
   ],
   "source": [
    "runBlocking {\n",
    "    val job = launch {\n",
    "        try {\n",
    "            delay(1000000)\n",
    "        } finally {\n",
    "            // withContext(NonCancellable) { // 이 부분의 주석을 풀어 보라\n",
    "                try {\n",
    "                    println(\"start\")\n",
    "                    delay(1000)\n",
    "                    println(\"end\")\n",
    "                } catch (exception: Exception) {\n",
    "                    println( exception )\n",
    "                }\n",
    "            // } /////////////////////////// // 이 부분의 주석을 풀어 보라 \n",
    "        }\n",
    "    }\n",
    "    delay(300)\n",
    "    job.cancel()\n",
    "    job.join()\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adb52d3f-d40f-4f9d-a54e-be1e973f6de2",
   "metadata": {},
   "source": [
    "### Parallel execution\n",
    "이 예제는 정확히 말하자면 병렬(parallel) 실행이 아니라 비동기(asynchronous) 실행의 사례"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0db228ab-5a15-4ae9-9d2b-f7577b155481",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "88"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import kotlin.random.*\n",
    "\n",
    "Random.nextInt(100) // 여러 번 반복해 실행해 보라"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4b7980a4-b1d7-4df4-818b-d2b5a04504a1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2023-07-26T04:32:16.739307"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.time.*\n",
    "\n",
    "LocalDateTime.now()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0d92ef2b-9eaf-4f7d-a54e-f4050d3d88be",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Image // dummy class\n",
    "\n",
    "suspend fun downloadImage(): Image {\n",
    "    delay( Random.nextInt(10) * 1000L )\n",
    "    return Image()\n",
    "}\n",
    "\n",
    "fun displayImages(img1: Image, img2: Image) {\n",
    "    println(\"$img1 ${LocalDateTime.now()}\")\n",
    "    println(\"$img2 ${LocalDateTime.now()}\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "699a09b6-89ff-49a7-99cf-994ee84f7efd",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image 1 start dn 2023-07-26T04:32:18.738234\n",
      "Image 2 start dn 2023-07-26T04:32:18.747939\n",
      "Image 1 downloaded 2023-07-26T04:32:21.749723\n",
      "Image 2 downloaded 2023-07-26T04:32:26.753299\n",
      "Line_13_jupyter$Image@6af4b32c 2023-07-26T04:32:26.755285\n",
      "Line_13_jupyter$Image@6dd234a3 2023-07-26T04:32:26.783672\n"
     ]
    }
   ],
   "source": [
    "runBlocking {\n",
    "    val job = Job().also { parentJob ->\n",
    "        val deferred1 = async(parentJob) {\n",
    "            println(\"Image 1 start dn ${LocalDateTime.now()}\")\n",
    "            downloadImage() \n",
    "        }.apply {\n",
    "            invokeOnCompletion { println(\"Image 1 downloaded ${LocalDateTime.now()}\") }\n",
    "        }\n",
    "        val deferred2 = async(parentJob) { \n",
    "            println(\"Image 2 start dn ${LocalDateTime.now()}\")\n",
    "            downloadImage() \n",
    "        }.apply {\n",
    "            invokeOnCompletion { println(\"Image 2 downloaded ${LocalDateTime.now()}\") }\n",
    "        }\n",
    "        displayImages(deferred1.await(), deferred2.await())\n",
    "    }\n",
    "    job.children.forEach { it.join() }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54766fd9-9da1-4376-9557-748875045bee",
   "metadata": {},
   "source": [
    "### Lazy executing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9713b828-ac0f-4aa8-ba41-69e887fbcc13",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "다른 걸 하아아안~~~ ~~~ ~~~\n",
      "~~~참 하다가 나중에 필요할 때\n",
      "Image start dn 2023-07-26T04:32:32.505754\n"
     ]
    }
   ],
   "source": [
    "runBlocking {\n",
    "    Job().also { parentJob ->\n",
    "        val job = launch(context = parentJob, start = CoroutineStart.LAZY) { \n",
    "            println(\"Image start dn ${LocalDateTime.now()}\")\n",
    "            downloadImage()\n",
    "        }\n",
    "        /////\n",
    "        println(\"다른 걸 하아아안~~~ ~~~ ~~~\")\n",
    "        delay(5000)\n",
    "        println(\"~~~참 하다가 나중에 필요할 때\")\n",
    "        /////\n",
    "        job.start()\n",
    "    }.children.forEach { it.join() }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "351dfe35-9b8e-4eef-96ec-0da42b11427c",
   "metadata": {},
   "source": [
    "### Channels\n",
    "비동기 실행은 시간 차이를 두고 결과가 하나만 나오는데\n",
    "\n",
    "일반적으로 여러 번에 걸쳐 여러 개가 나오는 것을 처리하려면 Channel을 쓰면 됨\n",
    "\n",
    "multi-thread로 실행되는 맥락(context)까지 고려한다면 일반적으로 코루틴 사이에는 상태를 공유하는 것은 위험\n",
    "\n",
    "그래서 Channel을 활용해 코루틴 사이에 안전하게 정보를 주고받을 수 있다 (즉, 코루틴 간의 동기화된 통신)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3ff5014a-9221-41c2-aefa-84341e8e9505",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "import kotlinx.coroutines.channels.*\n",
    "\n",
    "runBlocking {\n",
    "    val ch = Channel<Int>()\n",
    "    launch {\n",
    "        for (x in 1..10) {\n",
    "            ch.send(x * x)\n",
    "        }\n",
    "    }\n",
    "    repeat(10) {\n",
    "        delay(500)\n",
    "        println( ch.receive() )\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "802e5976-4c65-4ed4-b290-43411df9a184",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "runBlocking {\n",
    "    val ch = Channel<Int>()\n",
    "    launch {\n",
    "        for (x in 1..10) {\n",
    "            delay(500)\n",
    "            ch.send(x * x)\n",
    "        }\n",
    "    }\n",
    "    repeat(10) {\n",
    "        println( ch.receive() )\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eae7bf9a-2246-43de-8804-33c2af2ac5a8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Kotlin",
   "language": "kotlin",
   "name": "kotlin"
  },
  "language_info": {
   "codemirror_mode": "text/x-kotlin",
   "file_extension": ".kt",
   "mimetype": "text/x-kotlin",
   "name": "kotlin",
   "nbconvert_exporter": "",
   "pygments_lexer": "kotlin",
   "version": "1.8.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}