[Kotlin] 코틀린 Thread(스레드)에 관하여

 

안녕하세요 

오늘은 코틀린 Thread에 대하여 공부한 내용을

포스팅해보려 합니다.

 

Thread(스레드)란?

한 개의 프로세스 내에서 동시에 실행되는 작업의 단위를 말합니다.

 

아래에서 코틀린에서는 어떻게 Thread를 사용하는지 알아보겠습니다. 🤔

 

먼저, Thread클래스 상속을 통해 사용이 가능합니다.

 

class SimpleThread(private val threadName : String , private val delayTime : Long) : Thread(threadName){
    var flag = false
    override fun run() {
        while (!flag){
            sleep(delayTime)
            println("현제 쓰레드는${currentThread().name}입니다.")
        }
    }
}

fun main() {
    val thread1 = SimpleThread("thread1" , 500L) // main thread의 sub thread라고 말한다.
    val thread2 = SimpleThread("thread2" , 1000L) // 혹은 background thread라고 칭한다.

    thread1.start()
    thread2.start()

    try{
        Thread.sleep(5000)
        thread1.flag = true
        thread2.flag = true
    } catch (e : InterruptedException){
        //Todo Anything
    }
    println("Finish of ${Thread.currentThread().name}")
}

 

위 코드는 Thread클래스를 상속받은 'SimpleThread' 클래스를 main에서 생성하여 사용하는 예제입니다.

SimpleThread는 flag가 true가 될 때까지 전달해준 delay값만큼 텀을 주며 현재 thread의 이름을 출력하도록 하는 동작이며

main thread에서 5초 뒤에 두 SimpleThread의 flag값을 true로 주면서 Thread를 종료시킵니다.

 

위와 같이 Thread class에는 run() , start()가 존재하는데  start()를 호출 시에는 자동으로 run()이 실행되게 되어있습니다.

아울러, Thread 클래스를 상속받아 Thread를 만 들 경 우에는 반드시 run()을 구현하여야 합니다.

 

 

두 번째 Thread 사용 방법으로는

Runnable interface를 구현하여 Thread의 생성자 인자로 넘겨주는 방법입니다.

 

class SimpleRunnable(private val delayTime : Long) : Runnable {
    override fun run() {
        while(!Thread.interrupted()){
            try {
                Thread.sleep(delayTime)
                println(Thread.currentThread().name)
            } catch (e : InterruptedException){
                Thread.currentThread().interrupt()
                println("End of ${Thread.currentThread().name}")
            }
        }
    }
}

fun main() {
    val thread1 = Thread(SimpleRunnable(500L) , "쓰레드1")
    val thread2 = Thread(SimpleRunnable(100L) , "쓰레드2")

    thread1.start();thread2.start()

    try {
        Thread.sleep(5000)
        thread1.interrupt();thread2.interrupt()
    } catch (_ : InterruptedException){}
    println("End of ${Thread.currentThread().name}")
}

위 예제의 결괏값은 동일하나 Runnable을 구현하여 Thread생성자에 인자로 넘겨주는  방식으로 Thread를 사용한 방법입니다.

( interrupt()를 호출 시에는 InterruptException을 날리기에 반드시 catch안에서 처리를 해주어야 합니다. )

 

세 번째로는 thread()를 함수를 사용하는 방법이 있습니다.

 

import kotlin.concurrent.thread

fun main () {
    val thread1 = thread(start = false , name = "t500" ) {
        while(!Thread.interrupted()){
            try{
                Thread.sleep(500)
                println(Thread.currentThread().name)
            } catch (e : InterruptedException){
                Thread.currentThread().interrupt()
                println("End of ${Thread.currentThread().name}")
            }
        }
    }

    val thread2 = thread(start = false , name = "t1000"){
        while(!Thread.interrupted()){
            try{
                Thread.sleep(1000)
                println(Thread.currentThread().name)
            } catch (e : InterruptedException){
                Thread.currentThread().interrupt()
                println("End of ${Thread.currentThread().name}")
            }
        }
    }

    thread1.start(); thread2.start()
    try {
        Thread.sleep(5000)
        thread1.interrupt(); thread2.interrupt()
    } catch (e : InterruptedException){
        //Todo Anythings
    }
    println("End of ${Thread.currentThread().name}")
}

위 예제 또한 결괏값은 동일하나 thread()의 람다 함수를 통해 Thread를 생성하였습니다. 

 

이어서 마지막으로 Thread Pool을 이용한 방법이 존재하는데

여기서 Thread Pool(스레드 풀)이란

작업 처리에 사용되는 Thread를 제한된 개수만큼 정해놓고 작업 큐(Queue)에 들어오는 작업들을 하나씩 Thread가 맡아 처리하는 것을 말합니다.

Thread Pool을 사용 시에는 제한적인 리소스에서 스레드 관리가 용이 해집니다.

 

Thread Pool의 사용은 ExecutorService를 통해 가능하며

아래 함수들을 통해 생성이 가능합니다.

newFixedThredPool(n : Int) //n개의 thread를 만든다.

newCachedThreadPool() // Thread를 필요하다면 계속 생성 ,60초 후 사용되지 않는 Thread를 제거

newScheduledThreadPool(n : Int) // 주기적으로 실행되어야 하는 Thread가 필요할 때 사용

newSingleThreadExecutor() // 하나의 Thread만을 이용해서 작업할때 사용

 

간단한 예제를 한번 보겠습니다.

 

import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit

class PoolTask(private val threadName : String , private val delay : Long , private var flag : Boolean) : Runnable{
    override fun run() {
        while (flag){
            try {
                Thread.sleep(delay)
                println("Running.. ${Thread.currentThread().name}")
            } catch (e : InterruptedException){
                flag = false
            }
        }
    }
}

fun main() {
    val executorService = Executors.newFixedThreadPool(5)

    for(i in 1..5){
        val task = PoolTask("Thread${i}" , (i*100).toLong() , true)
        executorService.submit(task)
    }

    if(executorService.awaitTermination(5 , TimeUnit.SECONDS)){
        println("5초 안에 작업이 끝났다!")
    } else {
        println("아직 작업이 끝나지 않았다!!")
        executorService.shutdownNow()
    }
}

위 예제는 Runnable을 구현한 PoolTask 클래스를 Thread Pool로 넘겨주어 실행시킨 후

awaitTermination()을 통해 5초 동안 기다렸다가 종료되지 않을 경우 shutDownNow()으로

현재 실행 중인 모든 thread를 종료시킵니다.

 

이어서 Thread를 사용할 때 발생하는 동시성 문제에 대해 

해결할 수 있는 방법들에 대해 알아보겠습니다.

 

Mutex 기법

임계 영역(Critical Section)에 동시에 접근하지 못하도록 막는 기법 중 하나로 멀티 스레드에서 대기 중인 Thread는 대기 큐를 이용

 

Mutex기법 같은 경우 @Synchronized 키워드를 통해 임계 영역에 있는 속성이나 함수들에 lock을 걸어 줄 수 있습니다.

 

아래 코드를 보겠습니다.

package com.lee.thraed

class SharedCounter {
    var count = 0
    fun increment() {
        count++
    }
}

class UnSafeAccess(private val counter : SharedCounter) : Thread() {
    override fun run() {
        for(i in 1 .. 1000000000){
            counter.increment()
        }
    }
}

fun main() {
    val counter = SharedCounter()

    val t1 = UnSafeAccess(counter)
    val t2 = UnSafeAccess(counter)

    t1.start();t2.start()

    try {
        t1.join()
        t2.join()
    } catch (e : InterruptedException) {
        //Todo Something
    }
    println("counter : ${counter.count}")
}

위 예제는 Thread를 상속받은 UnSafeAccess를 통해 SharedCounter class에 있는 counter에 접근하는 코드로

동기화 처리를 진행하지 않아 각 Thread에서 동시에 접근하며 의도와는 다른 값이 출력되고 있습니다. 😒

 

동기화 처리가 진행되지 않아 값이 재대로 출력되지 않음

 

하지만 위 코드에 동기화 처리를 진행할 경우

 

class SharedCounter {
    var count = 0
    @Synchronized // 동기화 처리
    fun increment() {
        count++
    }
}

class UnSafeAccess(private val counter : SharedCounter) : Thread() {
    override fun run() {
        for(i in 1 .. 1000000000){
            counter.increment()
        }
    }
}

fun main() {
    val counter = SharedCounter()

    val t1 = UnSafeAccess(counter)
    val t2 = UnSafeAccess(counter)

    t1.start();t2.start()

    try {
        t1.join()
        t2.join()
    } catch (e : InterruptedException) {
        //Todo Something
    }
    println("counter : ${counter.count}")
}

 

동기화를 진행하여 올바른 값을 출력

 

위와 같이 올바른 값을 얻는 것을 볼 수 있습니다. 🤩 

 

다만 , 먼저 임계 영역에 들어간 Thread가 할 일을 다 끝내고 나올 때까지 lock을 걸어

다음 Thread는 접근하지 못하도록 하는 방식이기에

lock을 걸고 풀고 하는 동작들을 수행하며 다소 시간이 걸리는 것을 확인할 수 있었습니다.

 

Synchronize는 매우 강력하지만 잘못 사용할 경우 Thread끼리 서로 lock을 걸어 대기만 하다가

프로그램이 멈춰버리는 DeadLock(교착 상태)이 발생할 수 있다고 하니 

사용할 때 많은 주의가 필요할 것 같습니다.

 

Semaphore 기법

멀티 스레드 환경에서 다수의 스레드가 n개의 공유 자원에 대한 접근을 제한하는 방법으로 사용되는 동기화 기법

 

위 semaphore기법은 아직 추가적인 공부가 필요할 것 같습니다.. 😂

 

좀 더 공부하며 추가 포스팅하도록 하겠습니다.

 

이상으로 Kotlin Thread에 대한 포스팅을 마치겠습니다.

 

오늘도 즐코하세요 :)