코틀린 동시성 통신

코틀린에서 동시성 통신은 여러 코루틴 또는 스레드 간에 정보를 교환하고 동기화하는 프로세스를 의미합니다. 다수의 동시적 실행 흐름이 동일한 자원에 접근할 때 동기화가 필요하며, 코루틴은 Mutex, Channel 등을 사용하여 통신과 동기화를 수행할 수 있습니다.

 

1. Mutex (상호배제)

Mutex는 상호배제(Mutual Exclusion)를 제공하여 여러 스레드 또는 코루틴이 공유 데이터에 안전하게 접근할 수 있도록 합니다.

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

var counter = 0
val mutex = Mutex()

fun main() = runBlocking {
    val job = List(100) {
        launch {
            repeat(1000) {
                mutex.withLock {
                    counter++
                }
            }
        }
    }

    job.forEach { it.join() }
    println("Counter: $counter")
}

위의 예제에서 Mutex를 사용하여 여러 코루틴이 counter에 안전하게 접근하도록 보장합니다.

 

2. Channel (통신)

Channel은 생산자-소비자 패턴을 사용하여 코루틴 간에 안전하게 데이터를 교환할 수 있는 통신 수단을 제공합니다.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.Channel

fun main() = runBlocking {
    val channel = Channel<Int>()

    val producer = launch {
        repeat(5) {
            delay(200)
            channel.send(it)
        }
        channel.close()
    }

    val consumer = launch {
        for (element in channel) {
            println("Received: $element")
        }
    }

    producer.join()
    consumer.join()
}

위의 예제에서 Channel을 사용하여 생산자가 데이터를 보내고 소비자가 데이터를 받는 간단한 예를 보여줍니다.

 

3. Actor (상태 공유)

Actor는 코루틴 간에 메시지를 전송하고 상태를 공유하는 동기화된 방법을 제공합니다.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.actor

sealed class CounterMsg
object IncrementCounter : CounterMsg()
class GetCounter(val response: CompletableDeferred<Int>) : CounterMsg()

fun CoroutineScope.counterActor() = actor<CounterMsg> {
    var counter = 0
    for (msg in channel) {
        when (msg) {
            is IncrementCounter -> counter++
            is GetCounter -> msg.response.complete(counter)
        }
    }
}

fun main() = runBlocking {
    val counter = counterActor()

    repeat(1_000) {
        counter.send(IncrementCounter)
    }

    val response = CompletableDeferred<Int>()
    counter.send(GetCounter(response))
    println("Counter: ${response.await()}")

    counter.close()
}

위의 예제에서 Actor를 사용하여 코루틴 간에 counter 상태를 안전하게 공유하고 조작합니다.

 

4. Semaphore (제한된 자원 접근)

Semaphore는 제한된 개수의 자원에 대한 접근을 제어하는 데 사용됩니다.

import kotlinx.coroutines.*
import java.util.concurrent.Semaphore

val semaphore = Semaphore(2) // 최대 2개의 허용된 자원

fun main() = runBlocking {
    val jobs = List(5) {
        launch {
            println("Trying to access")
            semaphore.acquire()
            println("Accessing")
            delay(1000)
            println("Releasing")
            semaphore.release()
        }
    }

    jobs.forEach { it.join() }
}

위의 예제에서 Semaphore를 사용하여 동시에 최대 2개의 코루틴만 자원에 접근할 수 있도록 제한하고 있습니다.

동시성 통신은 안전하게 데이터를 공유하고 동기화하는 방법을 제공하여 다수의 동시적 실행 흐름이 안전하게 동작할 수 있도록 합니다. 여러 가지 통신 및 동기화 도구를 사용하여 특정 문제에 맞는 적절한 해결책을 선택할 수 있습니다.

 

With ChatGPT