kotlin 共享可变状态和并发性

协程与并发控制：线程安全与性能优化

最新推荐文章于 2025-09-22 23:20:17 发布

原创最新推荐文章于 2025-09-22 23:20:17 发布 · 175 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#kotlin

kotlin协程专栏收录该内容

8 篇文章

订阅专栏

本文探讨了在Kotlin中使用协程处理并发问题，包括使用`@Volatile`、原子变量、线程限制、互斥锁和Actor模型。通过示例展示了如何在并发环境中确保数据安全并优化性能，例如通过`AtomicInteger`实现线程安全的计数，以及使用`Mutex`和`withContext`进行细粒度的线程锁定。最后，引入了Actor模型来处理并发消息，确保状态的一致性。

//1.并发引发的问题
suspend fun masRun(action:suspend()->Unit){
    val a=100
    val b=1000
    val time= measureTimeMillis {
        coroutineScope {
            repeat(a){
                launch {
                    repeat(b){action()}
                }
            }
        }
    }
    println("actions: ${a * b} , 时间 $time ")//actions 100000  时间 49-80ms
}
@Volatile//Volatiles 是没有作用的
var count=0
fun  main_masRun() = runBlocking {
    withContext(Dispatchers.Default){
        masRun{
            count++
        }
    }
    println("总数 = $count")//68147 counter而不进行任何同步
}
//2.线程安全的数据结构解决并发问题
suspend fun masVolatile (action:suspend()->Unit){
    val a=100
    val b=1000
    val time= measureTimeMillis {
        coroutineScope {
            repeat(a){
                launch {
                    repeat(b){action()}
                }
            }
        }
    }
    println("actions: ${a * b} , 时间 $time ")//actions 100000  时间 52
}
var counts=AtomicInteger()//Volatiles 是没有作用的
fun  main_volatile () = runBlocking {
    withContext(Dispatchers.Default){
        masVolatile{
            counts.incrementAndGet()//之前是++
        }
    }
    println("总数 = $counts")//100000
}
//3.以细粒度限制线程
val counterContext= newSingleThreadContext("counterContext")
fun main_countercontext() = runBlocking {
    withContext(Dispatchers.Default){
        masVolatile{
            withContext(counterContext){//每个单独的增值操作都使用 withContext(counterContext)
                count++
            }
        }
    }

    println("总数 = $count")//100000
}
//4.以粗粒度限制线程
val counterContexts= newSingleThreadContext("counterContext")
fun main_countercontexts() = runBlocking {
    withContext(counterContexts){//线程限制是在比较大的范围内执行的
        masVolatile{
                count++
        }
    }
    println("总数 = $count")//100000 4152
}
//5.互斥
val mutex= Mutex()
fun main_mutex() = runBlocking {
    withContext(Dispatchers.Default){//线程限制是在比较大的范围内执行的
        masVolatile{
            mutex.withLock {//加锁 细粒度的
                count++
            }
        }
    }
    println("总数 = $count")//100000 4152
}
//6.Actors
sealed class CounterMsg
object IncCounter : CounterMsg()//增加的对象
class GetCounter(val response: CompletableDeferred<Int>) : CounterMsg()//请求的回应

fun CoroutineScope.counterActor() = actor<CounterMsg> {
    var counter = 0 // actor状态
    for (msg in channel) { // iterate over incoming messages
        when (msg) {
            is IncCounter -> counter++
            is GetCounter -> msg.response.complete(counter)
        }
    }
}
fun main_actor() = runBlocking<Unit> {
    val counter = counterActor() //增加一个actor
    withContext(Dispatchers.Default) {
        masVolatile {
            counter.send(IncCounter)
        }
    }
    //从actor得到发送来的值
    val response = CompletableDeferred<Int>()
    counter.send(GetCounter(response))
    println("Counter = ${response.await()}")
    counter.close() //关闭actor
}