Kotlin基础——异步和并发

同步和异步

• 同步指的是一种行为：当执行IO操作的时候，在代码层面上我们需要主动去等待结果，直到结果返回
• 阻塞指的是一种状态：当执行IO操作的时候，线程处于挂起状态，就是该线程没有执行了

故同步不是阻塞，同步也可以是非阻塞的，如在执行同步代码块时，线程可以不阻塞而是一直在后台运行

代码中一般通过和多线程和回调来实现异步非阻塞

但多线程只是看上去同时执行，底层原理是通过CPU调度来实现的，当一个线程切换到另一个线程时，通常需要

• 保存当前线程的执行上下文
• 载入另一个线程的执行上下文

切换线程也是需要开销的，故当线程切换很频繁时，可能会导致多线程并不优于单线程

协程Coroutine

大量回调会使代码更加复杂，且会存在多层次的回调，同时线程切换的开销不可忽略，而协程则可以避免这些问题

协程是一个无优先级的子程序调度组件，允许子程序在特定的地方挂起恢复

• 进程包含线程，线程包含协程
• 一个线程可以有任意多个协程
• 某一时刻只能由一个协程在运行，多个协程分享该线程分配到的计算机资源

implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.1"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.1"

使用Coroutine需要导入包，如下通过launch构造了一个协程，通过delay()挂起协程，但不会阻塞线程

GlobalScope.launch {
    delay(1000L)
    println("World")
}
println("Hello, ")
Thread.sleep(2000L)

线程是由操作系统来调度的，而协程的切换可以由程序自己来控制，协程可以创建很多个，而线程是有限的

launch和runBlocking

• delay只能在协程内部使用，用于挂起协程，不会阻塞线程
• sleep用来阻塞线程

未避免混淆，可以使用runBlocking创建主协程，而使用launch创建子协程，从而在内部都使用delay()，但需要注意，runBlocking依旧会阻塞当前执行的线程

fun test() = runBlocking {
    GlobalScope.launch {
        delay(1000L)
        println("World")
    }
    println("Hello, ")
    delay(2000L)
}

协程声明周期和join

当执行耗时操作，但并不知道需要多久时，为使程序一直保活，可以使用join

• 如下程序会一直等待，直到协程结束，这里的等待是非阻塞式，不会将当前线程挂起
• suspend修饰的方法只能在协程内部或其他suspend方法中使用

fun test() = runBlocking {
    val job = launch {
        search()
    }
    println("Hello,")
    job.join()
}

suspend fun search() {
    delay(1000L)
    println("World")
}

用同步方式写异步代码

在下面代码中，两个方法是顺序执行的

fun test() = runBlocking<Unit> {
    val one = searchOne()
    val two = searchTwo()
    println("search is ${one} and ${two}")
}

suspend fun searchOne() {
    delay(3000L)
    println("one")
}

suspend fun searchTwo() {
    delay(1000L)
    println("two")
}

打印如下

one
two
search is kotlin.Unit and kotlin.Unit

为了让其并行执行，可以使用async和await

• 使用async相当于创建了一个子协程，会和其他子协程一样并行工作
• async返回Deferred，是一个非阻塞可取消的future，其是一个带有结果的job，而Launch也会返回一个job但无返回值
• future的意思是将来会返回一个结果，利用await可以等待返回值查询到之后获取出来

fun test() = runBlocking<Unit> {
    val one = async { searchOne() }
    val two = async { searchTwo() }
    println("search is ${one.await()} and ${two.await()}")
}

打印如下

one
two
search is kotlin.Unit and kotlin.Unit

共享资源控制

锁

如对于下面的数据

val goods = hashMapOf<Long, Int>()
goods.put(1, 10)
goods.put(2, 15)

Synchronized

使用@Synchronized或synchronized()实现加锁

@Synchronized
fun buyGoods(id: Long) {
    val stock = goods.getValue(id)
    goods.put(id, stock - 1)
}
fun buyGoods2(id: Long) {
    synchronized(this) {
        val stock = goods.getValue(id)
        goods.put(id, stock - 1)
    }
}

Lock

var lock: Lock = ReentrantLock()
fun buyGoods3(id: Long) {
    lock.lock()
    try {
        val stock = goods.getValue(id)
        goods.put(id, stock - 1)
    } catch (ex: Exception) {
        println(ex)
    } finally {
        lock.unlock()
    }
}

上面写法有以下问题：

• 若有多个同步方法，将会竞争同一把锁
• 加锁后可能忘记解锁
• 重复的模板代码

fun <T> withLock(lock: Lock, action: () -> T) {
    lock.lock()
    try {
        action()
    } catch (ex: Exception) {
        println(ex)
    } finally {
        lock.unlock()
    }
}
fun buyGoods(id: Long) {
    val stock = goods.getValue(id)
    goods.put(id, stock - 1)
}
var lock: Lock = ReentrantLock()
withLock(lock, { buyGoods(1) })

上面使用高阶函数进行了优化，库函数也自带withLock()方法

fun buyGoods(id: Long) {
    val stock = goods.getValue(id)
    goods.put(id, stock - 1)
}
var lock: Lock = ReentrantLock()
lock.withLock({ buyGoods(1) })