《Kotlin从小白到大牛》第19章：线程

第19章 线程

无论PC（个人计算机）还是智能手机现在都支持多任务，都能够编写并发访问程序。多线程编程可以编写并发访问程序。本章介绍多线程编程。

19.1 基础知识

那么线程究竟是什么？在Windows操作系统出现之前，PC上的操作系统都是单任务系统，只有在大型计算机上才具有多任务和分时设计。随着Windows、Linux等操作系统出现，把原本只在大型计算机才具有的优点，带到了PC系统中。

19.1.1 进程
一般可以在同一时间内执行多个程序的操作系统都有进程的概念。一个进程就是一个执行中的程序，而每一个进程都有自己独立的一块内存空间、一组系统资源。在进程的概念中，每一个进程的内部数据和状态都是完全独立的。在Windows操作系统下可以通过Ctrl+Alt+Del组合键查看进程，在UNIX和Linux操作系统下是通过ps命令查看进程的。打开Windows当前运行的进程，如图19-1所示。
在Windows操作系统中一个进程就是一个exe或者dll程序，它们相互独立，互相也可以通信，在Android操作系统中进程间的通信应用也是很多的。

19.1.2 线程
线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序控制的流程，但与进程不同的是，同类的多个线程是共享一块内存空间和一组系统资源。所以系统在各个线程之间切换时，开销要比进程小的多，正因如此，线程被称为轻量级进程。一个进程中可以包含多个线程。

19.1.3 主线程
Kotlin程序至少会有一个线程，这就是主线程，程序启动后由Java虚拟机创建主线程，程序结束时由Java虚拟机停止主线程。主线程它负责管理子线程，即子线程的启动、挂起、停止等等操作。图19-2所示是进程、主线程和子线程的关系，其中主线程负责管理子线程，即子线程的启动、挂起、停止等操作。

获取主线程示例代码如下：
//代码文件：chapter19/src/com/a51work6/section1/ch19.1.3.kt
package com.a51work6.section1

import java.lang.Thread.currentThread

fun main(args: Array) {
//获取主线程
val mainThread =currentThread() ①
println(“主线程名：” + mainThread.name) ②
}
上述代码第①行是currentThread()函数获得当前线程，由于在main函数中当前线程就是主线程。currentThread()函数也可以表示成Thread.currentThread()，这样就不需要import
java.lang.Thread.currentThread语句了，Thread是Java提供的线程类。代码第②行的name属性获得线程的名字，主线程名是main，由Java虚拟机分配。

19.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参数线程体，是线程要执行的核心代码。

下面看一个具体示例代码如下：
//代码文件：chapter19/src/com/a51work6/section2/ch19.2.kt
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 0…9) {
// 打印次数和线程的名字
println(“第${i}次执行 - ${currentThread().name}”) ③

    // 随机生成休眠时间
    val sleepTime = (1000 * random()).toLong()    ④
    // 线程休眠
    sleep(sleepTime)       ⑤
    
}
// 线程执行结束
println("执行完成! " + currentThread().name)

}

fun main(args: Array) {
// 创建线程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-0
第0次执行 - MyThread
第1次执行 - MyThread
第1次执行 - Thread-0
第2次执行 - MyThread
第2次执行 - Thread-0
第3次执行 - MyThread
第3次执行 - Thread-0
第4次执行 - MyThread
第5次执行 - MyThread
第6次执行 - MyThread
第7次执行 - MyThread
第4次执行 - Thread-0
第8次执行 - MyThread
第5次执行 - Thread-0
第9次执行 - MyThread
第6次执行 - Thread-0
执行完成! MyThread
第7次执行 - Thread-0
第8次执行 - Thread-0
第9次执行 - Thread-0
执行完成! Thread-0

19.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），线程进入死亡状态有可能是正常执行完成进入，也可能是由于发生异常而进入的。

19.4 线程管理

线程管理是比较头痛的事情，这是学习线程的难点。下面分别介绍一下。

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

//共享变量
var value = 0 ①

fun main(args: Array) {

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
主线程结束…
子线程开始…
子线程执行…
子线程执行…
子线程结束…

19.4.2 线程让步
线程类Thread还提供一个yield函数，调用yield函数能够使当前线程给其他线程让步。它类似于sleep函数，能够使运行状态的线程放弃CPU使用权，暂停片刻，然后重新回到就绪状态。与sleep函数不同的是，sleep函数是线程进行休眠，能够给其他线程运行的机会，无论线程优先级高低都有机会运行。而yield函数只给相同优先级或更高优先级线程机会。
示例代码如下：
//代码文件：chapter19/src/com/a51work6/section4/ch19.4.2.kt
package com.a51work6.section4

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

// 编写执行线程代码
fun run() {
for (i in 0…9){
// 打印次数和线程的名字
println(“第${i}次执行 - ${currentThread().name}”)
yield() ①
}
// 线程执行结束
println("执行完成! " + currentThread().name)
}

fun main(args: Array) {
// 创建线程1
thread {
run()
}

// 创建线程2
thread(name ="MyThread") {
    run()
}

}
代码第①行yield函数能够使当前线程让步。

19.4.3 线程停止
线程体结束，线程进入死亡状态，线程就停止了。但是有些业务比较复杂，例如想开发一个下载程序，每隔一段执行一次下载任务，下载任务一般会在由子线程执行的，休眠一段时间再执行。这个下载子线程中会有一个死循环，但是为了能够停止子线程，设置一个结束变量。
示例代码如下：
//代码文件：chapter19/src/com/a51work6/section4/ch19.4.3.kt
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) {
// 创建线程t1
val t1 = thread {

    // 一直循环，直到满足条件在停止线程
    while (command !="exit") {          ②
        // 线程开始工作
        // TODO
        println("下载中...")
        // 线程休眠
        Thread.sleep(10000)
    }
    // 线程执行结束
    println("执行完成!")
}

command =readLine()!! // 接收从键盘输入的字符串   ③

}
上述代码第①行是设置一个结束变量。代码第②行是在子线程的线程体中判断，用户输入的是否为exit字符串，如果不是则进行循环，否则结束循环，结束循环就结束了线程体，线程就停止了。
代码第③行readLine函数接收从键盘输入的字符串。测试是需要注意：在控制台输入exit，然后敲Enter键，如图19-4所示。

本章小结

本章介绍了Kotlin线程技术，首先是介绍了线程相关的一些概念，然后介绍了如何创建子线程、线程状态和线程管理等内容，其中创建线程和线程管理是学习的重点。