第二十章多线程

课程重点:

线程相关概念的理解
线程的生命周期
线程的常用方法

20.1. 线程的简介

20.1.1. 串行与并发

如果在程序中，有多个任务需要被处理，此时的处理方式可以有串行和并发：

串行（同步）：所有的任务，按照一定的顺序，依次执行。如果前面的任务没有执行结束，后面的任务等待。
并发（异步）：将多个任务同时执行，在⼀个时间段内，同时处理多个任务。

生活中，其实有很多串行和并发的案例。最常见的就是排队买饭。小明到KFC吃饭，发现有好几个窗口可以点餐。选择了其中的一个窗口进行排队。此时， KFC采用的模式就是串行加并发的模式。每一个窗口之前，有很多顾客在排队，此时他们的任务是串行的，前面的顾客没有处理完之后，后面的顾客只能等待。同时，多个窗口之间的顾客是可以同时点餐的，他们是并发的。
使用并发任务，也可以在一定程度上提高效率。例如: 小明下班回到家，需要洗衣服、做饭、扫地。假设，洗衣服耗时10分钟，做饭耗时10分钟，洗衣服耗时10分钟，那么这些任务如果都给小明一件件的做，一共要耗时30分钟。如果小明找两个帮手，比如雇两个保姆，他们三个人每人处理一件任务，则共耗时10分钟。
在程序中，有些任务是比较耗时的，特别是涉及到非常大的文件的处理、或者网络文件的处理。此时就需要用异步任务来处理，否则就会阻塞主线程，导致用户的交互卡顿。合适的使用并发任务，可以在一定程度上提高程序的执行效率。

20.1.2. 并发的原理

一个程序如果需要被执行，必须的资源是CPU和内存。在内存上开辟空间，为程序中的变量进行数据的存储；同时需要CPU处理程序中的逻辑。现在处于一个硬件过剩的时代，但是即便是硬件不发达的时代，并发任务也是可以实现的。以单核的CPU为例，处理任务的核心只有一个，那就意味着，如果CPU在处理一个程序中的任务，其他所有的程序都得暂停。那么并发是怎么实现的呢？

其实所谓的并发，并不是真正意义上的多个任务同时执行。而是CPU快速的在不同的任务之间进行切换。在某一个时间点处理任务A，下一个时间点去处理任务B，每一个任务都没有立即处理结束。 CPU快速的在不同的任务之间进行切换，只是这个切换的速度非常快，人类是识别不了的，因此会给人一种“多个任务在同时执行”的假象。

因此，所谓的并发，其实就是CPU快速的在不同的任务之间进行切换的一种假象。

思考：
既然多个任务并发，可以在一定程度上提高程序的执行效率，那么并发数量是不是越高越好呢？
并不是！多个任务的并发，其实就是CPU在不同的任务之间进行切换。如果并发的数量过多，会导致分配到每一个任务上的CPU时间片较短，也并不见得会提高程序的执行效率。而且，每一个任务的载体（线程）也是需要消耗资源的，过多的线程，会导致其他资源的浪费。
例如: 上述案例中，我们说到了小明雇保姆干活，那么是不是保姆越多越好呢？
不一定！雇保姆需要花钱，就类比于开辟线程执行并发的任务需要消耗资源一样。那么在雇保姆的时候就得想，你真的需要这么多保姆吗？家里有十件事情需要处理，那么就一定需要雇十个保姆吗？没有必要！

20.1.3. 进程和线程

进程，是对一个程序在运行过程中，占用的各种资源的描述。
线程，是进程中的一个最小的执行单元。其实，在操作系统中，最小的任务执行单元并不是线程，而是句柄。只不过句柄过小，操作起来非常的麻烦，因此线程就是我们可控的最小的任务执行单元。

其实，对于操作系统来说，一个任务就是一个进程。例如，打开了QQ，就是一个QQ的进程；再打开一个QQ，就是一个新的QQ的进程；打开了一个微信，就是一个微信的进程。在一个任务中，有的时候是需要同时处理多件事情的，例如打开一个QQ音乐，需要同时播放声音和播放歌词。那么这些进程中的子任务，就是一个个的线程。

每一个进程至少要处理一件任务，因此，每一个进程中至少要包含一个线程。如果一个进程中所有的线程都结束了，那么这个进程也就结束了。

多个线程的同时执行，是需要这些线程去争抢CPU资源，而CPU资源的分配是以时间片为单位的。即某一个线程抢到了0.01秒的CPU时间片，在这个时间内， CPU处理这个线程的任务。至于哪一个线程能够抢到CPU时间片，则由操作系统进行资源调度。

20.1.4. 进程和线程的异同

相同点: 进程和线程都是为了处理多个任务并发而存在的。

不同点: 进程之间是资源不共享的，一个线程中不能访问另外一个进程中的数据。而线程之间是资源共享的，多个线程可以共享同一个数据。也正因为线程之间是资源共享的，所以会出现临界资源的问题。

20.1.5. 进程和线程的关系

一个进程，在开辟的时候，会自动的创建一个线程，来处理这个进程中的任务。这个线程被称为是主线程。在程序运行的过程中，还可以开辟其他线程，这些被开辟出来的其他线程，都是子线程。

也就是说，一个进程中，是可以包含多个线程。一个进程中的某一个线程崩溃了，只要还有其他线程存在，就不会影响整个进程的执行。但是如果一个进程中，所有的线程都执行结束了，那么这个进程也就终止了。

20.2. 线程的生命周期

20.2.1. 线程的状态

线程的生命周期，指的是一个线程对象，从最开始的创建，到最后的销毁，中间所经历的过程。在这个过程中，线程对象处于不同的状态。

New：新生态，一个线程对象刚被实例化完成的时候，就处于这个状态。
Runnable: 就绪态，处于这个状态的线程，可以参与CPU时间片的争抢。
Run: 运行态，某一个线程抢到了CPU时间片，可以执行这个线程中的逻辑
Block: 阻塞态，线程由于种种原因，暂时挂起，处于阻塞（暂停）状态。这个状态的线程，不参与CPU时间片的争抢。
Dead: 死亡态，线程即将被销毁。

20.2.2. 线程的生命周期图

format,png

20.3. 线程的常用方法

20.3.1. 线程对象的实例化

在Java中，使用Thread类来描述一个线程。实例化一个线程，其实就是一个Thread对象。

注意事项：每一个线程，开辟了之后，一定要是去处理某些任务而存在的。在进行线程的实例化的时候，需要指定这个线程要处理什么任务。

常见的线程的实例化，有以下两种方式:

20.3.1.1. 继承Thread类

继承自Thread类，做一个Thread的子类。在子类中，重写父类中的run方法，在这个重写的方法中，指定这个线程需要处理的任务。

/**
* @Description
*/
public class MyThread extends Thread {
@Override
public void run() {
// 这个线程需要处理的任务
for (int i = 0; i < 10; i++) {
System.out.println("hello world");
}
}
}

20.3.1.2. 使用Runnable接口

在Thread类的构造方法中，有一个重载的构造方法，参数是 Runnable 接口。因此，可以通过Runnable接口的实现类对象进行Thread对象的实例化。

/**
* @Description
*/
public class Program {
public static void main(String[] args) {
// Runnable接口的匿名实现类
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out,println("子线程处理的逻辑");
}
};
// 实例化线程对象
Thread thread = new Thread(runnable);
}
}

20.3.1.3. 优缺点对比

继承的方式：优点在于可读性比较强，缺点在于不够灵活。如果要定制一个线程，就必须要继承自Thread类，可能会影响原有的继承体系。
接口的方式：优点在于灵活，并且不会影响一个类的继承体系。缺点在于可读性较差。

后面课程中，用的比较多的方式是使用接口的方式。

20.3.2. 线程名字的设置

每一个线程，都有一个名字。如果在实例化线程的时候不去设定名字，那么这个线程会拥有一个默认的名字。

设置线程的名字，使用方法 setName(String name)

/**
* @Description
*/
public class Program {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
System.out.println("子线程的逻辑")；
});
// 设置线程的名字
thread.setName("子线程的名字");
}
}

Thread类对象，在进行实例化的时候，可以同时设置线程的名字。

/**
* @Description
*/
public class Program {
public static void main(String[] args) {
// 使用接口的方式进行线程的实例化
Thread thread = new Thread(() -> {}, "线程的名字");
}
}

如果使用继承Thread类的方式进行的实例化，可以添加一个构造方法，进行实例化对象的同时进行名称的设置。在构造方法中，使用 super(String) 进行父类方法的调用。

/**
* @Description
*/
public class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
System.out.println("子线程的逻辑");
}
}

设置线程名字，可以使用上述三种方式，但是获取线程线程的名字，只有一个方法，就是 getName()

/**
* @Description
*/
public class Program {
public static void main(String[] args) {
// 使用接口的方式进行线程的实例化
Thread thread = new Thread(() -> {}, "线程的名字");
System.out.println(thread.getName());
}
}

20.3.3. 线程的执行

线程对象刚刚被实例化的时候，线程处于新生态。如果需要让这个线程执行他的任务，需要调用 start() 方法，使线程进入到就绪态，争抢CPU时间片。

注意事项：

使用start()方法，不是run()方法！

使用start方法，会使得线程进入到就绪态，开始争抢CPU时间片，实现并发的任务。如果直接调用run方法，那么任务将会直接在当前线程中执行，并不会实现并发！

/**
* @Description
*/
public class Program {
public static void main(String[] args) {
// 使用接口的方式进行线程的实例化
Thread thread = new Thread(() -> {}, "线程的名字");
thread.start();
}
}

20.3.4. 线程的礼让

线程礼让，就是是的当前已经抢到CPU资源的正在运行的线程，释放自己持有的CPU资源，回到就绪状态，重新参与CPU时间片的争抢。

/**
* @Description
*/
public class Program {
public static void main(String[] args) {
// 使用接口的方式进行线程的实例化
Runnable runnable = () -> {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " : " + i);
if (i == 5) {
Thread.yield();
}
}
};
// 实例化两个线程，处理的逻辑完全相同
Thread thread0 = new Thread(runnable, "t0");
Thread thread1 = new Thread(runnable, "t1");
thread0.start();
thread1.start();
}
}

20.3.5. 线程的休眠

线程休眠，就是让当前的线程休眠指定的时间。休眠的线程进入到阻塞状态，直到休眠结束。阻塞的线程，不参与CPU时间片的争抢。

注: 线程休眠的时间单位是毫秒。

/**
* @Description
*/
public class Program {
public static void main(String[] args) {
// 使用接口的方式进行线程的实例化
Runnable runnable = () -> {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
// 线程休眠
Thread.sleep(1000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
};
// 实例化两个线程，处理的逻辑完全相同
Thread thread0 = new Thread(runnable, "t0");
Thread thread1 = new Thread(runnable, "t1");
thread0.start();
thread1.start();
}
}

20.3.6. 线程的合并

将一个线程中的任务，合并入到另外一个线程中执行，此时，合并进来的线程有限执行。类似于：插队。

/**
* @Description
*/
public class Program {
// 记录余票数量
static int ticketCount = 100;
public static void main(String[] args) {
// 循环卖票
while (ticketCount > 0) {
// 票数 -1
System.out.println("窗口卖出一张票给散客，剩余: " + --ticketCount);
// 卖出 30 张
if (ticketCount == 70) {
// 实例化⼀个 VIP 团体线程
Thread vip = new Thread(() -> {
for (int i = 0; i < 50; i++) {
System.out.println("窗口卖出一张票给VIP团队，剩余: " + --ticketCount);
}
});
// 先开启
vip.start();
// 再合并
try {
vip.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
Thread thread = new Thread(runnable);
thread.start();
}
}

20.3.7. 线程的优先级设置

设置线程的优先级，可以决定这个线程能够抢到CPU时间片的概率。线程的优先级范围在 [1, 10]，默认的优先级是5。数值越高，优先级越高。但是要注意，并不是优先级高的线程一定能抢到CPU时间片，也不是优先级的线程一定抢不到CPU时间片。线程的优先级只是决定了这个线程能够抢到CPU时间片的概率。即便是优先级最低的线程，依然可以抢到CPU时间片。