kotlin 共享可变状态和并发性

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

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

//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
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值