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")
        }
    }
}