1. .gradle中引入库
//协程
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.1"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.1"
2. 创建 CoroutinesTest.kt
class CoroutinesTest {
@Test
fun testCoroutines() {
}
}
3. launch 异步示例
3.1 launch,异步,不阻塞线程
/**
* 1.launch,异步,不阻塞线程
* GlobalScope.launch 具有生命中周期
*/
private fun testLaunch() {
val time: Long = measureTimeMillis {
GlobalScope.launch {
Thread.sleep(1000)
println("testLaunch 的launch 中, ${Thread.currentThread()} Good")
}
GlobalScope.launch {
Thread.sleep(1000)
println("testLaunch 的launch2 中, ${Thread.currentThread()} Good")
}
println("Hello? ${Thread.currentThread()}")
//由于代码函数生命周期的缘故,这里执行完代码块,jvm就销毁了函数栈,所有需要等待一下,才能看到 launch 的异步代码块的效果
Thread.sleep(2200)
}
println("函数总耗时 $time")
}
3.2 调用及输出结果
testLaunch()
/*Hello? Thread[Test worker,5,main]
testLaunch 的launch2 中, Thread[DefaultDispatcher-worker-3 @coroutine#2,5,main] Good
testLaunch 的launch 中, Thread[DefaultDispatcher-worker-2 @coroutine#1,5,main] Good
函数总耗时 2254*/
4. async 异步示例
4.1 async异步,不阻塞线程
/**
* 2.async,异步,不阻塞线程
* CoroutinesScope.async,具有生命周期的
*/
private fun testAsync() {
val time: Long = measureTimeMillis {
GlobalScope.async {
Thread.sleep(1000)
println("testAsync 的 async 中, ${Thread.currentThread()} Good")
}
GlobalScope.async {
Thread.sleep(1000)
println("testAsync 的 async2 中, ${Thread.currentThread()} Good")
}
println("Hello ${Thread.currentThread()}")
//由于代码函数生命周期的缘故,这里执行完代码块,jvm就销毁了函数栈,所有需要等待一下,才能看到 async 的异步代码块的效果
Thread.sleep(2200)
}
println("函数总耗时: $time")
}
4.2 调用及输出结果
testAsync()
/*Hello Thread[Test worker,5,main]
testAsync 的 async 中, Thread[DefaultDispatcher-worker-1 @coroutine#1,5,main] Good
testAsync 的 async2 中, Thread[DefaultDispatcher-worker-3 @coroutine#2,5,main] Good
函数总耗时: 2251*/
5. runBlocking 示例
5.1 runBlocking,阻塞线程
/**
* 3. runBlocking,阻塞线程
* 桥接普通函数和协程
*/
private fun testRunBlocking() {
var time: Long = measureTimeMillis {
runBlocking {
println("testRunBlocking 的block中 ${Thread.currentThread()} before delay")
delay(500)
println("testRunBlocking 的block中 ${Thread.currentThread()} -- after delay --")
}
println("testRunBlocking ${Thread.currentThread()} Hello")
}
println("函数总耗时: $time")
}
5.2 调用及输出结果
testRunBlocking()
/* testRunBlocking 的block中 Thread[Test worker @coroutine#1,5,main] before delay
testRunBlocking 的block中 Thread[Test worker @coroutine#1,5,main] -- after delay --
testRunBlocking Thread[Test worker,5,main] Hello
函数总耗时: 559*/
6. cancel join 示例
6.1 cancel join runBlocking 会等待内部协程执行完毕才结束
/**
* 4. cancel join
* runBlocking 会等待内部协程执行完毕才结束,对比 test1 的jvm
* 异步的特性,注意执行输出的结果
*/
private fun testCancelJoin() = runBlocking {
var time: Long = measureTimeMillis {
val L1: Job = launch {
//Thread.sleep(1000)
println("testCancelJoinTimeOut >> Launch1 ${Thread.currentThread()} L1 Hello")
}
val L2: Job = launch {
println("testCancelJoinTimeOut >> Launch2 ${Thread.currentThread()} L2 Hello")
}
var a2 = async {
repeat(20) {
println("testCancelJoinTimeOut >> async2 ${Thread.currentThread()} $it A2 Good")
delay(200)
//Thread.sleep(1000)
}
}
//a2.cancelAndJoin()//取消协程,并返回主协程
// a2.join()//如此则必须 a2 结束协程,才会走下面的
var a1 = async {
println("testCancelJoinTimeOut >> async ${Thread.currentThread()} A1 Hello")
//测试取消 a2
a2.cancel()
}
println("testCancelJoinTimeOut ${Thread.currentThread()} Out")
}
println("函数总耗时 $time")
}
6.2 调用及输出结果
testCancelJoin()
/* testCancelJoinTimeOut Thread[Test worker @coroutine#1,5,main] Out
函数总耗时 8
testCancelJoinTimeOut >> Launch1 Thread[Test worker @coroutine#2,5,main] L1 Hello
testCancelJoinTimeOut >> Launch2 Thread[Test worker @coroutine#3,5,main] L2 Hello
testCancelJoinTimeOut >> async2 Thread[Test worker @coroutine#4,5,main] 0 A2 Good
testCancelJoinTimeOut >> async Thread[Test worker @coroutine#5,5,main] A1 Hello*/
7.time out 示例
7. time out 示例
7.1 执行超时抛出异常
/**
* 5. time out
* 执行超时抛出异常
*/
private fun testTimeOut() = runBlocking {
val time = measureTimeMillis {
//超时自动取消内部协程,抛异常
withTimeout(2000) {
// repeat(200) {
// println("withTimeOut 的${Thread.currentThread()} $it")
// delay(300)
// }
launch {
repeat(200) {
println("withTimeOut中 launch 的 ${Thread.currentThread()} $it")
delay(300)
}
}
println("withTimeOut ${Thread.currentThread()}")
}
withTimeoutOrNull(1000) {
println("withTimeoutOrNull ${Thread.currentThread()}")
}
}
println("函数总耗时 ----- $time")
}
7.2 调用及输出结果
//testTimeOut()
/* withTimeOut Thread[Test worker @coroutine#1,5,main]
withTimeOut中 launch 的 Thread[Test worker @coroutine#2,5,main] 0
withTimeOut中 launch 的 Thread[Test worker @coroutine#2,5,main] 1
withTimeOut中 launch 的 Thread[Test worker @coroutine#2,5,main] 2
withTimeOut中 launch 的 Thread[Test worker @coroutine#2,5,main] 3
withTimeOut中 launch 的 Thread[Test worker @coroutine#2,5,main] 4
withTimeOut中 launch 的 Thread[Test worker @coroutine#2,5,main] 5
withTimeOut中 launch 的 Thread[Test worker @coroutine#2,5,main] 6
Timed out waiting for 2000 ms
kotlinx.coroutines.TimeoutCancellationException: Timed out waiting for 2000 ms*/
8. await 示例
8.1 await,async的异步deferred结果获取
/**
* await,async的异步deferred结果获取
*/
private fun testAwait() = runBlocking {
val time: Long = measureTimeMillis {
val a2 = async {
println("testAwait ${Thread.currentThread()} A2 Good")
delay(3000)
100
}
//a2.join()
val a1 = async {
getA1()
}
//a1.join()
println("result ${Thread.currentThread()} -- ${a1.await()} ${a2.await()}")
}
println("函数总耗时: $time")
}
//suspend fun 挂起函数
private suspend fun getA1(): Int {
println("testAwait>>async ${Thread.currentThread()} A1 Good")
delay(2000)
return 99
}
8.2 调用及输出结果
testAwait()
/* testAwait Thread[Test worker @coroutine#2,5,main] A2 Good
testAwait>>async Thread[Test worker @coroutine#3,5,main] A1 Good
result Thread[Test worker @coroutine#1,5,main] -- 99 100
函数总耗时: 3013*/