Android面试题之Kotlin协程并发问题和互斥锁

本文首发于公众号“AntDream”，欢迎微信搜索“AntDream”或扫描文章底部二维码关注，和我一起每天进步一点点

Kotlin 语言提供了多种机制来处理并发和同步，其中包括高层次和低层次的工具。对于常规的并发任务，可以利用 Kotlin 协程提供的结构化并发方式。而对于需要更低层次的锁定机制，可以使用 Mutex来实现对共享资源的线程安全访问。

Kotlin 协程与并发（Coroutines and Concurrency）

协程是一种轻量级的线程，可以通过 kotlinx.coroutines库来实现。协程为结构化并发提供了强大的支持，使得编写异步、并发代码变得更加简单和直观。

协程基础

import kotlinx.coroutines.*
fun main() = runBlocking {
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello,")
}

在这个例子中，runBlocking函数用于启动一个新的协程并阻塞当前线程，而 launch函数则用于启动一个新的协程，并在1秒后输出 "World!"。

并发与同步

当多个协程需要访问共享资源时，需要一些同步机制来防止数据竞争。一个常用的方法是使用 Kotlin 库提供的 Mutex。

Mutex

Mutex（互斥锁）是一种用于保证互斥访问共享资源的同步机制。Mutex确保在同一时刻只有一个协程能够访问被保护的代码块或资源，从而避免竞争条件。

使用 Mutex

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
val mutex = Mutex()
var counter = 0
fun main() = runBlocking {
    val jobs = List(100) {
        launch {
            repeat(1000) {
                // 在这里使用 mutex 来保护对 counter 的访问
                mutex.withLock {
                    counter++
                }
            }
        }
    }
    jobs.forEach { it.join() }
    println("Counter = $counter")
}

在这个例子中，我们创建了100个协程，每个协程重复1000次对共享变量 counter的访问。使用 mutex.withLock保证了每次只有一个协程能访问 counter，从而避免并发问题。

withLock()是一种便捷方法，用于在锁内执行给定的代码块。它会自动处理获取和释放锁，确保即使在代码块中发生异常，也会正确释放锁。

Mutex的其他方法

lock：挂起直到互斥锁被锁定。

lock()方法用于尝试获取锁。如果锁已经被其他协程持有，那么调用 lock()的协程将会被挂起，直到锁变为可用。

用法

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
val mutex = Mutex()
fun main() = runBlocking {
    launch {
        mutex.lock() // 获取锁
        try {
            // 保护的代码段
            println("Locked by coroutine 1")
            delay(1000)
        } finally {
            mutex.unlock() // 确保释放锁
        }
    }
    launch {
        mutex.lock() // 等待并获取锁
        try {
            // 保护的代码段
            println("Locked by coroutine 2")
        } finally {
            mutex.unlock() // 确保释放锁
        }
    }
}

unlock：解锁互斥锁。

unlock()方法用于释放锁，使得被挂起的其他协程可以继续执行。如果 unlock()被调用时没有持有锁，则会引发异常。

用法

如上面 lock()示例中的 finally块所示。

tryLock

tryLock()尝试获取锁，如果锁当前是可用的，则立即获取锁并返回 true；否则返回 false，且不会挂起当前协程。

用法

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
val mutex = Mutex()
fun main() = runBlocking {
    launch {
        if (mutex.tryLock()) { // 尝试获取锁
            try {
                println("Lock acquired by coroutine 1")
                delay(1000)
            } finally {
                mutex.unlock()
            }
        } else {
            println("Coroutine 1: Lock not acquired")
        }
    }
    launch {
        if (mutex.tryLock()) { // 尝试获取锁
            try {
                println("Lock acquired by coroutine 2")
            } finally {
                mutex.unlock()
            }
        } else {
            println("Coroutine 2: Lock not acquired")
        }
    }
}

总结

• lock()：尝试获取锁，如果锁不可用，则挂起当前协程。
• unlock()：释放锁，其他挂起的协程可以继续执行。
• tryLock()：尝试获取锁，如果锁不可用，则立即返回 false，不会挂起当前协程。
• withLock()：便捷方法，自动获取和释放锁，确保在代码块执行后释放锁。

Mutex的这些方法使得在 Kotlin 协程中进行线程安全的操作变得更加简洁和直观。根据实际需求选择合适的方法，可以有效避免并发问题，提高代码的健壮性和可维护性。

欢迎关注我的公众号AntDream查看更多精彩文章！

热门文章

最新文章