课程重点:
- 线程相关概念的理解
- 线程的生命周期
- 线程的常用方法
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. 线程的生命周期图
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时间片。
/** * @Description */public class Program { public static void main(String[] args) { // 使用接口的方式进行线程的实例化 Runnable runnable = () -> { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + " : " + i); } }; // 实例化两个线程， 处理的逻辑完全相同 Thread thread0 = new Thread(runnable, "t0"); Thread thread1 = new Thread(runnable, "t1"); // 设置线程的优先级， 必须在这个线程启动之前 thread0.setPriority(1); thread1.setPriority(10); thread0.start(); thread1.start(); }}20.3.8. 当前线程的获取
- Thread.currentThread() : 可以用在任意的位置， 获取当前的线程。
- 如果是Thread的子类， 可以在子类中， 使用this获取到当前的线程。
20.3.9. 守护线程
守护线程， 又叫后台线程。 是一个运行在后台， 并且会和前台线程争抢CPU时间片的线程。
- 守护线程依然会和前台线程争抢CPU时间片， 实现并发的任务。
- 在一个进程中， 如果所有的前台线程都结束了， 后台线程即便任务没有执行结束， 也会自动结束。
/** * @Description */public class Program { public static void main(String[] args) { // 实例化一个线程 Thread thread = new Thread(() -> { while (true) { System.out.println("守护线程在运行")； try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); // 将一个线程设置为守护线程 thread.setDaemon(true); // 开启线程 thread.start(); for (int i = 0; i < 10; i++) { System.out.println("主线程: " + i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }
扫一扫
922
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
