Android开发之Kotlin(三)

一、线程

1 基础知识
在Windows操作系统出现之前,PC上的操作系统都是单任务系统,只有在大型计算机上才具有多任务和分时设计。随着Windows、Linux等操作系统出现,把原本只在大型计算机才具有的优点,带到了PC系统中。
1.1 进程
一般可以在同一时间内执行多个程序的操作系统都有进程的概念。一个进程就是一个执行中的程序,而每一个进程都有自己独立的一块内存空间、一组系统资源。在进程的概念中,每一个进程的内部数据和状态都是完全独立的。在Windows操作系统下可以通过Ctrl+Alt+Del组合键查看进程,在UNIX和Linux操作系统下是通过ps命令查看进程的。在Windows操作系统中一个进程就是一个exe或者dll程序,它们相互独立,互相也可以通信,在Android操作系统中进程间的通信应用也是很多的。
1.2 线程
线程与进程相似,是一段完成某个特定功能的代码,是程序中单个顺序控制的流程,但与进程不同的是,同类的多个线程是共享一块内存空间和一组系统资源。所以系统在各个线程之间切换时,开销要比进程小的多,正因如此,线程被称为轻量级进程。一个进程中可以包含多个线程。
1.3 主线程
Kotlin程序至少会有一个线程,这就是主线程,程序启动后由Java虚拟机创建主线程,程序结束时由Java虚拟机停止主线程。主线程它负责管理子线程,即子线程的启动、挂起、停止等等操作。图19-2所示是进程、主线程和子线程的关系,其中主线程负责管理子线程,即子线程的启动、挂起、停止等操作。
Android开发之Kotlin(三)_第1张图片
获取主线程示例代码如下:

package com.a51work6.section1

import java.lang.Thread.currentThread

fun main(args: Array) {undefined
	//获取主线程
	val mainThread =currentThread()println(“主线程名:” + mainThread.name)}

上述代码第①行是currentThread()函数获得当前线程,由于在main函数中当前线程就是主线程。currentThread()函数也可以表示成Thread.currentThread(),这样就不需要import
java.lang.Thread.currentThread语句了,Thread是Java提供的线程类。代码第②行的name属性获得线程的名字,主线程名是main,由Java虚拟机分配。

2 创建线程
在Java中线程类是Thread,Kotlin中的线程也是使用了Java中Thread类。Java中创建一个线程比较麻烦,而Kotlin中非常简单,使用thread函数就可以,thread函数定义如下:

fun thread(
	start: Boolean= true,
	isDaemon:Boolean = false,
	contextClassLoader: ClassLoader? = null,
	name: String? =null,
	priority: Int =-1,
	block: () ->Unit
): Thread

thread 函数返回类型是Thread类,函数中start参数是否创建完成线程马上启动,在Java中启动线程需要另外调用start函数;isDaemon参数是否为守护线程,守护线程是一种在后台长期运行线程,守护线程主要提供一些后台服务,它的生命周期与Java虚拟机一样长;contextClassLoader参数是类加载器,用来加载一些资源等;name参数是指定线程名,如果不指定线程名,系统会分配一个线程名;priority参数是设置线程优先级;block参数线程体,是线程要执行的核心代码。
在这里插入图片描述
下面看一个具体示例代码如下:

package com.a51work6.section2

import java.lang.Math.random
import java.lang.Thread.currentThread
import java.lang.Thread.sleep
import kotlin.concurrent.thread ①

// 编写执行线程代码
fun run() {for (i in 09) {undefined
		// 打印次数和线程的名字
		println(“第${i}次执行 - ${currentThread().name})// 随机生成休眠时间
	    val sleepTime = (1000 * random()).toLong()// 线程休眠
	    sleep(sleepTime)}
	// 线程执行结束
	println("执行完成! " + currentThread().name)
	
	}
	```
	fun main(args: Array) {undefined
		// 创建线程1
		thread {run()
	}
	// 创建线程2
		thread(name = "MyThread") {run()
	}
}

上述代码第①行引入thread函数,该函数来自于kotlin.concurrent包。代码第②行的声明一个自定义run函数,由于多个线程中需要执行相同代码,所以这里声明次函数,在函数中进行十次循环,每次让当前线程休眠一段时间。代码第③行是打印次数和线程的名字,currentThread函数可以获得当前线程对象,name是Thread类的属性,可以获得线程的名。代码第④行使用random函数计算随机数,来自于Java中的Math类。代码第⑤行sleep(sleepTime)是在指定的毫秒数内让当前线程休眠,来自于Thread类。
代码第⑥行和第⑦行是使用thread函数创建两个线程。其中第⑦行创建的线程指定了线程名为MyThread。
运行结果如下:

0次执行 - Thread-00次执行 - MyThread
第1次执行 - MyThread
第1次执行 - Thread-02次执行 - MyThread
第2次执行 - Thread-03次执行 - MyThread
第3次执行 - Thread-04次执行 - MyThread
第5次执行 - MyThread
第6次执行 - MyThread
第7次执行 - MyThread
第4次执行 - Thread-08次执行 - MyThread
第5次执行 - Thread-09次执行 - MyThread
第6次执行 - Thread-0
执行完成! MyThread
第7次执行 - Thread-08次执行 - Thread-09次执行 - Thread-0
执行完成! Thread-0

3 线程状态
在线程的生命周期中,线程会有几种状态,如图19-3所示,线程有5种状态。下面分别介绍一下。
1.新建状态
新建状态(New)是通过实例化Thread创建线程对象,它仅仅是一个空的线程对象。
2.就绪状态
当主线程调用新建线程的start()函数后,它就进入就绪状态(Runnable)。此时的线程尚未真正开始执行线程体,它必须等待CPU的调度。
3.运行状态
CPU的调度就绪状态的线程,线程进入运行状态(Running),处于运行状态的线程独占CPU,执行完成线程体。
4.阻塞状态
因为某种原因运行状态的线程会进入不可运行状态,即阻塞状态(Blocked),处于阻塞状态的线程Java虚拟机系统不能执行该线程,即使CPU空闲,也不能执行该线程。如下几个原因会导致线程进入阻塞状态:
o 当前线程调用sleep函数,进入休眠状态。
o 被其他线程调用了join函数,等待其他线程结束。
o 发出I/O请求,等待I/O操作完成期间。
o 当前线程调用wait函数。
处于阻塞状态可以重新回到就绪状态,如:休眠结束、其他线程加入、I/O操作完成和调用notify或notifyAll唤醒wait线程。
5.死亡状态
线程执行完成线程体后,就会进入死亡状态(Dead),线程进入死亡状态有可能是正常执行完成进入,也可能是由于发生异常而进入的。
Android开发之Kotlin(三)_第2张图片

4 线程管理
4.1 等待线程结束
在介绍现在状态时提到过join函数,当前线程调用t1线程的join函数,会阻塞当前线程等待t1线程结束,如果t1线程结束或等待超时,则当前线程回到就绪状态。
Thread类提供了多个版本的join,它们定义如下:
o join()。等待该线程结束。
o join(millis : Long)。等待该线程结束的时间最长为millis毫秒。如果超时为0意味着要一直等下去。
使用join函数示例代码如下:

package com.a51work6.section4

//共享变量
var value = 0fun main(args: Array) {undefined
println("主线程main函数开始...")
// 创建线程t1 
val t1 = thread {println("子线程开始...")
    for (i in 0..1) {
        println("子线程执行...")
        value++}
    println("子线程结束...")
}
// 主线程被阻塞,等待t1线程结束
t1.join()println("value = $value")println("主线程main函数结束...")
}

运行结果如下:

主线程main函数开始…
子线程开始…
子线程执行…
子线程执行…
子线程结束…
value = 2
主线程main函数结束…

上述代码第①行是声明了一个共享变量value,这个变量在子线程中修改,然后主线程访问它。代码第②行是采用thread函数创建线程。代码第③行是在子线程中修改共享变量value。
代码第④行是在当前线程(主线程)中调用t1的join函数,因此会导致主线程阻塞,等待t1线程结束,从运行结果可以看出主线程被阻塞了。代码第⑤行是打印共享变量value,从运行结果可见value = 2。
如果尝试将t1.join()语句注释掉,输出结果如下:

主线程开始…
value = 0
主线程结束…
子线程开始…
子线程执行…
子线程执行…
子线程结束…

在这里插入图片描述
4.2 线程让步
线程类Thread还提供一个yield函数,调用yield函数能够使当前线程给其他线程让步。它类似于sleep函数,能够使运行状态的线程放弃CPU使用权,暂停片刻,然后重新回到就绪状态。与sleep函数不同的是,sleep函数是线程进行休眠,能够给其他线程运行的机会,无论线程优先级高低都有机会运行。而yield函数只给相同优先级或更高优先级线程机会。
示例代码如下:

package com.a51work6.section4

import java.lang.Thread.currentThread
import java.lang.Thread.yield
import kotlin.concurrent.thread

// 编写执行线程代码
fun run() {undefined
	for (i in 09){undefined
	// 打印次数和线程的名字
	println(“第${i}次执行 - ${currentThread().name})
	yield()}
	// 线程执行结束
	println("执行完成! " + currentThread().name)
	}
	
	fun main(args: Array) {undefined
	// 创建线程1
	thread {undefined
	run()
}
	
	// 创建线程2
	thread(name ="MyThread") {
	    run()
	}
}

代码第①行yield函数能够使当前线程让步。
在这里插入图片描述
4.3 线程停止
线程体结束,线程进入死亡状态,线程就停止了。但是有些业务比较复杂,例如想开发一个下载程序,每隔一段执行一次下载任务,下载任务一般会在由子线程执行的,休眠一段时间再执行。这个下载子线程中会有一个死循环,但是为了能够停止子线程,设置一个结束变量。
示例代码如下:

package com.a51work6.section4

import java.io.BufferedReader
import java.io.IOException
import java.io.InputStreamReader
import java.lang.Thread.sleep
import kotlin.concurrent.thread

var command = “” ①

fun main(args: Array) {undefined
	// 创建线程t1
	val t1 = thread {undefined
	    // 一直循环,直到满足条件在停止线程
	    while (command !="exit") {// 线程开始工作
	        // TODO
	        println("下载中...")
	        // 线程休眠
	        Thread.sleep(10000)
	    }
	    // 线程执行结束
	    println("执行完成!")
	}
	
	command =readLine()!! // 接收从键盘输入的字符串   ③
}

上述代码第①行是设置一个结束变量。代码第②行是在子线程的线程体中判断,用户输入的是否为exit字符串,如果不是则进行循环,否则结束循环,结束循环就结束了线程体,线程就停止了。
代码第③行readLine函数接收从键盘输入的字符串。
在这里插入图片描述

二、协程

协程与线程类似都可以处理并发任务。协程在很多语言中都支持,但Java没有协程支持,Kotlin支持协程编程。
1 协程介绍
协程(Coroutines)是一种轻量级的线程,协程提供了一种不阻塞线程,但是可以被挂起的计算过程。线程阻塞开销是巨大的,而协程挂起基本上没有开销。
在执行阻塞任务时,会将这种任务放到子线程中执行,执行完成再回调(callback)主线程,更新UI等操作,这就是异步编程。协程底层库也是异步处理阻塞任务,但是这些复杂的操作被底层库封装起来,协程代码的程序流是顺序的,不再需要一堆的回调函数,就像同步代码一样,也便于理解、调试和开发。
线程是抢占式的,线程调度是操作系统级的。而协程是协作式的,而协程调度是用户级的,协程是用户空间线程,与操作系统无关,所以需要用户自己去做调度。

2 创建协程
1.1 Kotlin协程API
Kotlin支持协程,通过了丰富的协程编程所需的API,主要是三个方面的支持:
1.语言支持。Kotlin语言本身提供一些对协程的支持,例如Kotlin中的suspend关键字可以声明一个挂起函数。
2.底层API。Kotlin标准库中包含协程编程核心底层API,来自于kotlin.coroutines.experimental包,这些底层API虽然也可以编写协程代码,但是使用起来非常麻烦,笔者不推荐直接使用这些底层API。
3.高级API。高级API使用起来很简单,但Kotlin标准库中没有高级API,它来自于Kotlin的扩展项目kotlinx.coroutines框架(https://github.com/Kotlin/kotlinx.coroutines),使用时需要额外配置项目依赖关系。kotlinx.coroutines包名是kotlinx.coroutines.experimental。
在这里插入图片描述
2.2 创建支持kotlinx.coroutines项目
由于kotlinx.coroutines提供了高级API,使用起来较标准库中底层API要简单的多。本书重点介绍使用kotlinx.coroutines实现协程编程。kotlinx.coroutines不属于Kotlin标准库,需要额外配置项目依赖关系,因此需要创建IntelliJ IDEA+Gradle项目,项目创建完成后在打开build.gradle文件,添加依赖关系,具体内容如下:

group ‘com.51work6’
version ‘1.0-SNAPSHOT’

apply plugin: ‘java’
apply plugin: ‘kotlin’

sourceCompatibility = 1.8

repositories {
	mavenCentral()
}

dependencies {
	compile “org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version”
	compile ‘org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.3’ ①
	testCompile group: ‘junit’, name:‘junit’, version:4.12}

compileKotlin {
	kotlinOptions.jvmTarget =1.8}
compileTestKotlin {
	kotlinOptions.jvmTarget =1.8}
group ‘com.51work6’
version ‘1.0-SNAPSHOT’

buildscript {
	ext.kotlin_version =1.1.51’ ②
	repositories {
	    mavenCentral()
	}
	dependencies {
	    classpath"org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
	}
}

上述代码第①行compile 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.19.3’是刚刚添加的依赖关系。另外,还需要检查代码第②行的ext.kotlin_version是否是最新Kotlin版本。
2.3 第一个协程程序
协程是轻量级的线程,因此协程也是由主线程管理的,如果主线程结束那么协程也就结束了。下面看看第一个协程示例:

package com.a51work6.section2

import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.launch
import java.lang.Math.random
import java.lang.Thread.sleep

fun main(args: Array) {
	launch { //启动一个协程 ①
		for (i in 09) {
		// 打印协程执行次数
		println(“子协程执行第${i}次”)
		// 随机生成挂起时间
		val sleepTime = (1000 * random()).toLong()
		// 协程挂起
		delay(sleepTime)}
		println(“子协程执行结束。”)
	}
	sleep(10000L) // 主线程休眠,保持其他线程处于活动状态 ③
	println(“主协程结束。”)

}

运行结果如下:

子协程执行第0次
子协程执行第1次
子协程执行第2次
子协程执行第3次
子协程执行第4次
子协程执行第5次
子协程执行第6次
子协程执行第7次
子协程执行第8次
子协程执行第9次
子协程执行结束。
主协程结束。

上述代码第①行launch函数创建并启动一个协程,类似于线程的thread函数。代码第②行是delay函数是挂起协程,类似于线程的sleep函数,但不同的是delay函数不会阻塞线程,而sleep函数会阻塞线程。代码第③行是让主线程休眠10秒,如果这里主线程不休眠,主线程直接就结束了,其他的线程或协程没有机会运行。
2.4 launch函数与Job对象
在上一节的示例中用到了launch函数是非常重要的,它的定义如下:

fun launch(
	context:CoroutineContext = DefaultDispatcher,
	start:CoroutineStart = CoroutineStart.DEFAULT,
	block: suspend CoroutineScope.() -> Unit
): Job

context参数是协程上下文对象默认在DefaultDispatcher,DefaultDispatcher通常是一个公共线程池。start参数设置协程启动,block参数是协程体,类似于线程体,协程执行的核心代码在此编写,在协程体中执行的函数应该都是挂起函数,例如delay函数就是挂起的。
launch函数的返回是一个Job对象,Job是协程要执行的任务,可以将Job对象看做协程本身,所有对协程的操作都是通过Job对象完成的,协程的状态和生命周期都是通过Job反映出来的。
在这里插入图片描述
Job对象中常用的属性和函数如下:

o isActive属性。判断Job是否处于活动状态。
o isCompleted属性。判断Job是否处于完成状态。
o isCancelled属性。判断Job是否处于取消状态。
o start函数。开始Job。
o cancel函数。取消Job。
o join函数。是当前协程处于等待状态,直到Job完成,join是一个挂起函数只能在协程体中或其他的挂起函数中调用。

示例代码如下:

package com.a51work6.section2

import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.launch
import java.lang.Math.random
import java.lang.Thread.sleep

fun main(args: Array) {
	val job =launch {//启动一个协程
		for (i in0…9) {
			// 打印协程执行次数
			println(“子协程执行第${i}次”)
			// 随机生成挂起时间
			val sleepTime = (1000 * random()).toLong()
			// 协程挂起
			delay(sleepTime)
		}
		println(“子协程执行结束。”)
	}
	println(job.isActive) //true ②
	println(job.isCompleted)//false ③
	sleep(10000L) // 主线程休眠,保持其他线程处于活动状态
	println(“主协程结束。”)
	println(job.isCompleted) //true ④
}

上述代码第①行调用launch函数创建并开始一个协程,并返回Job对象赋值给job变量。代码第②行是判断job是否处于活动状态,代码第③行是判断job是否处于完成状态,由于协程还没有执行完成,因此这里返回false。代码第④行是返回true。
2.5 使用runBlocking函数
为了保持保持其他线程处于活动状态,前面两节示例中都使用sleep函数。sleep函数是线程提供的函数,在协程中最好不要使用,应该使用协程自己的delay函数,但delay是挂起函数,必须在协程体中或其他的挂起函数中使用。
修改2.3节示例代码如下:

package com.a51work6.section2

import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.launch
import kotlinx.coroutines.experimental.runBlocking
import java.lang.Math.random

fun main(args: Array) = runBlocking {val job = launch {
		//启动一个协程
		for (i in 09) {
			// 打印协程执行次数
			println(“子协程执行第${i}次”)
			// 随机生成挂起时间
			val sleepTime = (1000 *random()).toLong()
			// 协程挂起
			delay(sleepTime)
			}
		println(“子协程执行结束。”)
	}
	delay(10000L) // 主协程挂起 ②
	println(“主协程结束。”)
}

上述代码第①行是将main代码放到runBlocking函数中,runBlocking函数也是启动并创建一个协程,可以与顶层函数一起使用。代码第②行是使用delay函数挂起主协程。
2.6 挂起函数
如果需要开发人员也可以编写的挂起函数,其实也很简单就在函数声明时候使用suspend关键字,示例如下:

suspend fun run() {}

在这里插入图片描述

fun main(args: Array) {
run()
}

挂起函数不仅可以是顶层函数,还可以是成员函数,还可以是抽象函数,子类重写挂起函数后还应该是挂起的。示例代码如下:

abstract class SuperClass {
	suspend abstract fun run()
}
class SubClass : SuperClass() {
	override suspend fun run() {}
}

上述代码SubClass类实现了抽象类SuperClass的抽象挂起函数run,重写后它还是挂起函数。
示例代码如下:

package com.a51work6.section2
…
suspend fun run(name: String) {//启动一个协程
	for (i in 09) {
		// 打印协程执行次数
		println(“子协程n a m e 执 行 第 {name}执行第name执行第{i}次”)
		// 随机生成挂起时间
		val sleepTime = (1000 *random()).toLong()
		// 协程挂起
		delay(sleepTime)
		}
		println(“子协程${name}执行结束。”)
	}
	
	fun main(args: Array) = runBlocking {
		//启动一个协程1
		val job1 = launch() {run(“job1”)}
		//启动一个协程2
		val job2 = launch {run(“job2”)}
	delay(10000L) // 主协程挂起
	println(“主协程结束。”)
}

运行结果如下:

子协程job1执行第0次
子协程job2执行第0次
子协程job1执行第1次
子协程job2执行第1次
子协程job1执行第2次
子协程job1执行第3次
子协程job1执行第4次
子协程job1执行第5次
子协程job2执行第2次
子协程job2执行第3次
子协程job1执行第6次
子协程job1执行第7次
子协程job2执行第4次
子协程job1执行第8次
子协程job2执行第5次
子协程job2执行第6次
子协程job1执行第9次
子协程job2执行第7次
子协程job1执行结束。
子协程job2执行第8次
子协程job2执行第9次
子协程job2执行结束。
主协程结束。

上述代码第①行是声明一个挂起函数,代码第②行和第③行是创建创建并启动两个协程,在它们的协程体中分别调用run函数。
3 协程生命周期
在协程的生命周期是通过Job的几种状态体现的,如图20-1所示,Job协程有6种状态。下面分别介绍一下。
1.新建状态
新建状态是主要是通过launch函数创建协程对象,它仅仅是一个空的协程对象。
2.活动状态
新建协程调用start函数后,它就进入活动状态。launch函数通过start参数设置是否启动协程。处于活动状态的协程会执行协程体。
3.正在完成状态
正在完成状态是一个瞬间过渡状态,从活动状态进入到已完成状态时经历的中间状态。
4.已完成状态
协程成功执行协程体完,就会进入已完成状态,这是最终状态,说明这个协程已经停止。
5.正在取消状态
活动状态或正在完成状态时,如果调用了cancel函数则会进入已取消状态,在此之前要先进入正在取消状态,正在取消状态也是一个瞬间过渡状态。
6.已取消状态
在新建状态、活动状态或正在完成状态时,如果调用了cancel函数最终都会已取消状态,只是新建状态没有经历正在取消状态,而是直接已取消状态。已取消状态是最终状态,说明这个协程已经停止。

Android开发之Kotlin(三)_第3张图片
Job状态可以通过Job的isActive、isCompleted和isCancelled属性判断而知。

Android开发之Kotlin(三)_第4张图片

4 管理协程
4.1 等待协程结束
前面提到过join函数,协程的join函数与线程的join函数类似。如果在当前协程中调用job1协程的join函数,则会阻塞当前协程,直到job1协程结束当前协程才会继续运行状态。
示例代码如下:

package com.a51work6.section4

import kotlinx.coroutines.experimental.launch
import kotlinx.coroutines.experimental.runBlocking

//共享变量
var value = 0fun main(args: Array) = runBlocking {
	println("主协程开始...")
	// 创建协程job1
	val job1 = launch {println("子协程开始...")
	    for (i in 0..1) {
	        println("子协程执行...")
	        value++}
	    println("子协程结束...")
	}
	// 主协程被挂起,等待job1协程结束
	job1.join()println("value = $value")println("主协程结束...")
}

运行结果如下:

主协程开始…
子协程开始…
子协程执行…
子协程执行…
子协程结束…
value = 2
主协程结束…

上述代码第①行是声明了一个共享变量value,这个变量在子协程中修改,然后主协程访问它。代码第②行是创建并启动协程job1。代码第③行是在子协程中修改共享变量value。
代码第④行是在当前协程(主协程)中调用job1的join函数,因此会导致主协程挂起,等待job1协程结束,从运行结果可以看出主协程被挂起了。代码第⑤行是打印共享变量value,从运行结果可见value = 2。
如果尝试将job1.join()语句注释掉,输出结果如下:

主协程开始…
value = 0
主协程结束…

从运行结果看,如果一个主协程没有挂,子协程根本没有机会运行,程序就直接结束了。
在这里插入图片描述
4.2 超时设置
协程在挂起时有时需要设置超时限制,设置超时使用withTimeout函数。示例代码如下:

package com.a51work6.section4

import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.runBlocking
import kotlinx.coroutines.experimental.withTimeout

suspend fun run(name: String) {
	//启动一个协程
	for (i in 09) {
		// 打印协程执行次数
		println(“子协程n a m e 执 行 第 {name}执行第name执行第{i}次”)
		// 随机生成挂起时间
		val sleepTime = (1000 *Math.random()).toLong()
		// 协程挂起
		delay(sleepTime)
		}
		println(“子协程${name}执行结束。”)
	}
	
	fun main(args: Array) = runBlocking {
	//启动一个协程1
	withTimeout(2000L) {run(“job1”)
	}
	println(“主协程结束。”)
}

执行结果如下:

子协程job1执行第0次
子协程job1执行第1次
子协程job1执行第2次
子协程job1执行第3次
子协程job1执行第4次
Exception in thread “main” kotlinx.coroutines.experimental.TimeoutCancellationException:
Timed out waiting for 2000 MILLISECONDS
at kotlinx.coroutines.experimental.ScheduledKt.TimeoutCancellationException(Scheduled.kt:185)
at
…

上述代码第①行调用withTimeout函数,设置超时时间为2秒,超过2秒抛出异常,需要执行的协程体放到withTimeout{…}中,withTimeout也会创建并启动一个协程,但它的返回的不是Job对象。
4.3 取消协程
协程体结束,协程进入完成状态,协程就停止了。但是有些业务比较复杂,例如想开发一个下载程序,每隔一段执行一次下载任务,下载任务一般会在由子协程执行的,挂起一段时间再执行。这个下载子协程中会有一个死循环,但是为了能够停止子协程,可以调用cancel函数或cancelAndJoin函数取消协程。
示例代码如下:

package com.a51work6.section4

import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.launch
import kotlinx.coroutines.experimental.runBlocking

fun main(args: Array) = runBlocking {
	// 创建协程
	val job = launch {
	// 一直循环,直到满足条件在取消协程
	while (true) {// 协程开始工作
		// TODO
		println(“下载中…”)
		delay(10000L)
		}
	}
	val command =readLine()// 读取从键盘的字符串          ②
	if (command =="exit") {       
	job.cancel()//取消协程 ③
	job.join()//等待协程结束
	//job.cancelAndJoin()//取消协程并等待协程job结束 ④
	}
}

上述代码第①行是设置while循环一直执行协程体,直到有程序取消它。代码第②行读取从键盘的字符串,如果输入的是exit,则取消协程。代码第③行是取消协程,取消协程往往需要调用join等待job协程结束,否则可能会出现job还没有结束,主协程已经结束。如果两个函数都调用也可以使用cancelAndJoin函数替代,见代码第④行

你可能感兴趣的:(android,kotlin,java)