[1] Kotiln Coroutines - Coroutine Builder/Scope/Suspend function/Structured Concurrency

Why Coroutine?

https://wooooooak.github.io/kotlin/2019/08/25/%EC%BD%94%ED%8B%80%EB%A6%B0-%EC%BD%94%EB%A3%A8%ED%8B%B4-%EA%B0%9C%EB%85%90-%EC%9D%B5%ED%9E%88%EA%B8%B0/

 

Ref.

Youtube :  [새차원, 코틀린 코루틴] https://youtube.com/playlist?list=PLbJr8hAHHCP5N6Lsot8SAnC28SoxwAU5A

Ref : https://kotlinlang.org/

 

[ 중요한 개념 ]
* Coroutine Builder → [launch] , [runBlocking]
* Scope → [CoroutineScope] , [GlobalScope]
* Suspend function → [suspend] , [delay()], [join()]
* Structured Concurrency

 

 

 

[↓예제 ] Coroutine과 Job 에 대해 이해하기 쉬운 예제

 

    runBlocking {
        GlobalScope.launch {
            delay(3000L) // 이렇게 되면 아래 2초 후 종료, 코루틴은 3초 후 실행하고 싶은 거니 처리가 안됨.
            println("World!")
        }
        println("Hello,")
        delay(2000L)
    }

 

    val job = GlobalScope.launch {
        delay(3000L)
        println("World!")
    }

    println("Hello")
    job.join() // join을 통해 job 이 완료 될 때까지 기다릴 수 있게 됨.

 

    // Structured concurrency : 
    // 기다리기 위해 sleep 이나 job.join()을 했는데 이것보다 좋은 방법이 있다! 바로!
    fun main() = runBlocking {
        // val job = GlobalScope → this ( GlobalScope 에서 Coroutine Scope로)
        this.launch {
            delay(1000L)
            println("World!")
        }

        // this 생략 가능 - 람다 안쪽에 this 있기 때문에
        launch {
            delay(1000L)
            println("World!")
         }


        println("Hello,")
   
   
   // job.join() // 이런식으로 관리 해준다면, job.join() , job1.join(), job2.join() 이런 식으로 쓰면 복잡해진다. 이런거 방지 위함.

    // runBlocking 과 launch 코루틴이 구조적으로 관계를 갖는다면, 서로 기다려주고 살 수 있지 않겠는가!
    // >> 탑레벨 코루틴을 만들지 말고, 해당 루틴의 차일드로 코루틴을 만들면, 
    // 상위 부모 코루틴이 차일드 코루틴 완료되는 것까지 기다려주는
    // 구조적인 형태를 관리해라~

}

 

 

 

[↓예제 ] Structured Concurrency를 만들어서 코루틴 두 개를 만든다.

fun main() = runBlocking {
                launch {
                    repeat(5){
                        i -> println("코루틴 A ${i}")
            delay(10L) // suspend function 인 delay를 주면 
            // 옆에 일시 중단 표시가 됨 (코루틴 B에 중단 함수가 없으면 B가 다시 실행되고 A 로 돌아옴)
        }
    }

    launch {
        repeat(5){
            i->println("코루틴 B ${i}")
            delay(10L)
        }
    }

    println("Coroutine Outer")
}

// 어떤 스레드에서 실행이 되었는지 print 함수를 오버라이드
fun <T>println(msg: T){
    kotlin.io.println("$msg [ ${Thread.currentThread().name} ]")
}

 

출력 결과

Coroutine Outer [ main ]
코루틴 A 0 [ main ]
코루틴 B 0 [ main ]
코루틴 A 1 [ main ]
코루틴 B 1 [ main ]
코루틴 A 2 [ main ]
코루틴 B 2 [ main ]
코루틴 A 3 [ main ]
코루틴 B 3 [ main ]
코루틴 A 4 [ main ]
코루틴 B 4 [ main ]

 

 

---