day10-多线程
一、多线程常用方法
下面我们演示一下getName()
、setName(String name)
、currentThread()
、sleep(long time)
这些方法的使用效果。
public class MyThread extends Thread{
public MyThread(String name){
super(name); // 为当前线程设置名字了
}
@Override
public void run() {
// 哪个线程执行它,它就会得到哪个线程对象。
Thread t = Thread.currentThread();
for (int i = 1; i <= 5; i++) {
System.out.println(t.getName() + "大声叫:吕布小儿 莫跑~~接我" + i+"招");
}
}
}
再测试类中,创建线程对象,并启动线程
/**
* 目标:掌握Thread的常用方法。
*/
public class ThreadTest1 {
public static void main(String[] args) {
System.out.println("接下来请欣赏 三英战吕布");
for (int i = 5; i >= 1; i--) {
System.out.println(i);
Thread.sleep(1000);
}
MyThread t1 = new MyThread("刘备");
// t1.setName("刘备");
t1.start();
System.out.println(t1.getName()); // Thread-0
MyThread t2 = new MyThread("关羽");
// t2.setName("关羽");
t2.start();
System.out.println(t2.getName()); // Thread-1
MyThread t3 = new MyThread("张飞");
// t3.setName("张飞");
t3.start();
System.out.println(t3.getName()); // Thread-1
}
}
执行上面代码,效果如下图所示,我们发现每一条线程都有自己了名字了。
最后再演示一下join这个方法是什么效果。
/**
* 目标:掌握join方法的作用。
*/
public class ThreadTest2 {
public static void main(String[] args) throws Exception {
System.out.println("关羽和总部一起打吕布");
// join方法作用:让当前调用这个方法的线程先执行完。
MyThread t = new MyThread("关羽");
t.start();
Thread.currentThread().setName("总部");
for (int i = 1; i <=5; i++) {
System.out.println(Thread.currentThread().getName()+"发射弓箭弩~~第"+i+"发");
}
}
}
不加join执行效果是 此时你会发现关于线程没有执行完总部线程就执行了(效果是多次运行才出现的,根据个人电脑而异,可能有同学半天也出现不了也是正常的)
public class ThreadTest2 {
public static void main(String[] args) throws Exception {
System.out.println("关羽和总部一起打吕布");
// join方法作用:让当前调用这个方法的线程先执行完。
MyThread t = new MyThread("关羽");
t.start();
t.join();
Thread.currentThread().setName("总部");
for (int i = 1; i <=5; i++) {
System.out.println(Thread.currentThread().getName()+"发射弓箭弩~~第"+i+"发");
}
}
}
我们再尝试,把join()方法加上,再看执行效果。 执行多次 关于执行完 总部才执行
二、线程安全问题
各位小伙伴,前面我们已经学习了如何创建线程,以及线程的常用方法。接下来,我们要学习一个在实际开发过程中,使用线程时最重要的一个问题,叫线程安全问题。
2.1 线程安全问题概述
- 首先,什么是线程安全问题呢?
线程安全问题指的是,多个线程同时操作同一个共享资源的时候,可能会出现业务安全问题。
下面通过一个取钱的案例给同学们演示一下。案例需求如下
场景:小明和小红是一对夫妻,他们有一个共享账户,余额是10万元,小红和小明同时来取钱,并且2人各自都在取钱10万元,可能出现什么问题呢?
如下图所示,小明和小红假设都是一个线程,本类每个线程都应该执行完三步操作,才算是完成的取钱的操作。但是真实执行过程可能是下面这样子的
① 小红线程只执行了判断余额是否足够(条件为true),然后CPU的执行权就被小红线程抢走了。
② 小红线程也执行了判断了余额是否足够(条件也是true), 然后CPU执行权又被小明线程抢走了。
③ 小明线程由于刚才已经判断余额是否足够了,直接执行第2步,吐出了10万元钱,此时共享账户月为0。然后CPU执行权又被小红线程抢走。
④ 小红线程由于刚刚也已经判断余额是否足够了,直接执行第2步,吐出了10万元钱,此时共享账户月为-10万。
你会发现,在这个取钱案例中,两个人把共享账户的钱都取了10万,但问题是只有10万块钱啊!!!
以上取钱案例中的问题,就是线程安全问题的一种体现。
2.2 线程安全问题的代码演示
先定义一个共享的账户类
public class Account {
private String cardId; // 卡号
private double money; // 余额。
public Account() {
}
public Account(String cardId, double money) {
this.cardId = cardId;
this.money = money;
}
// 小明 小红同时过来的
public void drawMoney(double money) {
// 先搞清楚是谁来取钱?
String name = Thread.currentThread().getName();
// 1、判断余额是否足够
if(this.money >= money){
System.out.println(name + "来取钱" + money + "成功!");
this.money -= money;
System.out.println(name + "来取钱后,余额剩余:" + this.money);
}else {
System.out.println(name + "来取钱:余额不足~");
}
}
public String getCardId() {
return cardId;
}
public void setCardId(String cardId) {
this.cardId = cardId;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
}
在定义一个是取钱的线程类
public class DrawThread extends Thread{
private Account acc;
public DrawThread(Account acc, String name){
super(name);
this.acc = acc;
}
@Override
public void run() {
// 取钱(小明,小红)
acc.drawMoney(100000);
}
}
最后,再写一个测试类,在测试类中创建两个线程对象
public class ThreadTest {
public static void main(String[] args) {
// 1、创建一个账户对象,代表两个人的共享账户。
Account acc = new Account("ICBC-110", 100000);
// 2、创建两个线程,分别代表小明 小红,再去同一个账户对象中取钱10万。
new DrawThread(acc, "小明").start(); // 小明
new DrawThread(acc, "小红").start(); // 小红
}
}
运行程序,执行效果如下。你会发现两个人都取了10万块钱,余额为-10完了。
2.3 线程同步方案
为了解决前面的线程安全问题,我们可以使用线程同步思想。同步最常见的方案就是加锁,意思是每次只允许一个线程加锁,加锁后才能进入访问,访问完毕后自动释放锁,然后其他线程才能再加锁进来。
等小红线程执行完了,把余额改为0,出去了就会释放锁。这时小明线程就可以加锁进来执行,如下图所示。
采用加锁的方案,就可以解决前面两个线程都取10万块钱的问题。怎么加锁呢?Java提供了三种方案
1.同步代码块
2.同步方法
3.Lock锁
2.4 同步代码块
我们先来学习同步代码块。它的作用就是把访问共享数据的代码锁起来,以此保证线程安全。
//锁对象:必须是一个唯一的对象(同一个地址)
synchronized(锁对象){
//...访问共享数据的代码...
}
使用同步代码块,来解决前面代码里面的线程安全问题。我们只需要修改DrawThread类中的代码即可。
// 小明 小红线程同时过来的
public void drawMoney(double money) {
// 先搞清楚是谁来取钱?
String name = Thread.currentThread().getName();
// 1、判断余额是否足够
// this正好代表共享资源!
synchronized (this) {
if(this.money >= money){
System.out.println(name + "来取钱" + money + "成功!");
this.money -= money;
System.out.println(name + "来取钱后,余额剩余:" + this.money);
}else {
System.out.println(name + "来取钱:余额不足~");
}
}
}
此时再运行测试类,观察是否会出现不合理的情况。
最后,再给同学们说一下锁对象如何选择的问题
1.建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象
2.对于实例方法,建议使用this作为锁对象
3.对于静态方法,建议把类的字节码(类名.class)当做锁对象
2.5 同步方法
接下来,学习同步方法解决线程安全问题。其实同步方法,就是把整个方法给锁住,一个线程调用这个方法,另一个线程调用的时候就执行不了,只有等上一个线程调用结束,下一个线程调用才能继续执行。
// 同步方法
public synchronized void drawMoney(double money) {
// 先搞清楚是谁来取钱?
String name = Thread.currentThread().getName();
// 1、判断余额是否足够
if(this.money >= money){
System.out.println(name + "来取钱" + money + "成功!");
this.money -= money;
System.out.println(name + "来取钱后,余额剩余:" + this.money);
}else {
System.out.println(name + "来取钱:余额不足~");
}
}
改完之后,再次运行测试类,观察是否会出现不合理的情况。
接着,再问同学们一个问题,同步方法有没有锁对象?锁对象是谁?
同步方法也是有锁对象,只不过这个锁对象没有显示的写出来而已。
1.对于实例方法,锁对象其实是this(也就是方法的调用者)
2.对于静态方法,锁对象时类的字节码对象(类名.class)
最终,总结一下同步代码块和同步方法有什么区别?
1.不存在哪个好与不好,只是一个锁住的范围大,一个范围小
2.同步方法是将方法中所有的代码锁住
3.同步代码块是将方法中的部分代码锁住
2.6 Lock锁
接下来,我们再来学习一种,线程安全问题的解决办法,叫做Lock锁。
Lock锁是JDK5版本专门提供的一种锁对象,通过这个锁对象的方法来达到加锁,和释放锁的目的,使用起来更加灵活。格式如下
1.首先在成员变量位子,需要创建一个Lock接口的实现类对象(这个对象就是锁对象)
private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码
lk.lock(); // 加锁
//...中间是被锁住的代码...
lk.unlock(); // 解锁
使用Lock锁改写前面DrawThread中取钱的方法,代码如下
// 创建了一个锁对象
private final Lock lk = new ReentrantLock();
public void drawMoney(double money) {
// 先搞清楚是谁来取钱?
String name = Thread.currentThread().getName();
try {
lk.lock(); // 加锁
// 1、判断余额是否足够
if(this.money >= money){
System.out.println(name + "来取钱" + money + "成功!");
this.money -= money;
System.out.println(name + "来取钱后,余额剩余:" + this.money);
}else {
System.out.println(name + "来取钱:余额不足~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lk.unlock(); // 解锁
}
}
}
运行程序结果,观察是否有线程安全问题。到此三种解决线程安全问题的办法我们就学习完了。
三、线程通信(了解)
接下来,我们学习一下线程通信。
首先,什么是线程通信呢?
- 当多个线程共同操作共享资源时,线程间通过某种方式互相告知自己的状态,以相互协调,避免无效的资源挣抢。
线程通信的常见模式:是生产者与消费者模型
- 生产者线程负责生成数据
- 消费者线程负责消费生产者生成的数据
- 注意:生产者生产完数据后应该让自己等待,通知其他消费者消费;消费者消费完数据之后应该让自己等待,同时通知生产者生成。
比如下面案例中,有3个厨师(生产者线程),两个顾客(消费者线程)。
接下来,我们先分析一下完成这个案例的思路
1.先确定在这个案例中,什么是共享数据?
答:这里案例中桌子是共享数据,因为厨师和顾客都需要对桌子上的包子进行操作。
2.再确定有那几条线程?哪个是生产者,哪个是消费者?
答:厨师是生产者线程,3条生产者线程;
顾客是消费者线程,2条消费者线程
3.什么时候将哪一个线程设置为什么状态
生产者线程(厨师)放包子:
1)先判断是否有包子
2)没有包子时,厨师开始做包子, 做完之后把别人唤醒,然后让自己等待
3)有包子时,不做包子了,直接唤醒别人、然后让自己等待
消费者线程(顾客)吃包子:
1)先判断是否有包子
2)有包子时,顾客开始吃包子, 吃完之后把别人唤醒,然后让自己等待
3)没有包子时,不吃包子了,直接唤醒别人、然后让自己等待
按照上面分析的思路写代码。先写桌子类,代码如下
// Desk表示桌子 因为生产者生产的包子要放在桌子上
// 消费者也在桌子上吃
public class Desk {
// 使用集合 当接收 包子的盘子
private List<String> list = new ArrayList<>();
/*
两个方法加了锁,目的是 在吃包子的时候不能运行包包子,
在包包子的时候 不能运行吃包子。
在方法加锁 是因为懒!锁是 当前的对象this。
*/
// 在桌子上 包(生产)包子方法
public synchronized void make(){
try{
//生产包子
String name = Thread.currentThread().getName();//获取生产者线程的名字
if(list.size()==0){//没有包子
String baozi = name+"做的西红柿鸡蛋包子";
list.add(baozi);
System.out.println(name+"做了一个西红柿鸡蛋包子");
//模拟一个包子 两秒出来
Thread.sleep(1000);
//包子有了 唤醒 消费者
this.notify();//唤醒单个线程 随机...
// this.notifyAll();//唤醒所有的线程
this.wait();//停下来不做了 释放掉锁
}
}catch (Exception e){
e.printStackTrace();
System.out.println("不好意思...西红柿跟鸡蛋跑了....");
}
}
// 在桌子上 吃(消费)包子方法
public synchronized void eat(){
//吃包子
try{
//吃包子
String name = Thread.currentThread().getName();//获取消费者线程的名字
if(list.size()==1){//有包子
String baozi = list.get(0);
list.clear();//光盘
System.out.println(name+"正在吃"+baozi);
//模拟吃一个包子 两秒出来
Thread.sleep(500);
//包子没有 唤醒 生产者
this.notify();//唤醒单个线程 随机...
// this.notifyAll();//唤醒所有的线程
this.wait();//停下来不吃了 释放掉锁
}
}catch (Exception e){
e.printStackTrace();
System.out.println("不好意思...钱跟着风跑了....");
}
}
}
再写测试类,在测试类中,创建3个厨师线程对象,再创建2个顾客对象,并启动所有线程
public class PoTianTiang {
public static void main(String[] args) {
// 需求 3 个生产者 负责生成包子 每次产生一个包子 放在桌子上
// 2个消费者 吃包子 每次只吃一个包子 包子合理有效利用起来。
// 先玩 一个生产者 一个消费者
Desk desk = new Desk();
//创建一个 生产者
new Thread(()->{
//生成包子
while(true){
desk.make();//只要这个线程存在就可以一直做
}
},"霍大厨").start();
new Thread(()->{
//生成包子
while(true){
desk.make();//只要这个线程存在就可以一直做
}
},"宇小厨").start();
new Thread(()->{
//生成包子
while(true){
desk.make();//只要这个线程存在就可以一直做
}
},"卧龙凤厨").start();
//创建一个消费者
new Thread(()->{
while(true){
//吃包子
desk.eat();
}
},"杨云普").start();
//创建一个消费者
new Thread(()->{
while(true){
//吃包子
desk.eat();
}
},"慈吃货").start();
}
}
执行上面代码,运行结果如下:你会发现多个线程相互协调执行,避免无效的资源挣抢。
霍大厨做了一个西红柿鸡蛋包子
慈吃货正在吃霍大厨做的西红柿鸡蛋包子
卧龙凤厨做了一个西红柿鸡蛋包子
慈吃货正在吃卧龙凤厨做的西红柿鸡蛋包子
霍大厨做了一个西红柿鸡蛋包子
慈吃货正在吃霍大厨做的西红柿鸡蛋包子
霍大厨做了一个西红柿鸡蛋包子
慈吃货正在吃霍大厨做的西红柿鸡蛋包子
霍大厨做了一个西红柿鸡蛋包子
慈吃货正在吃霍大厨做的西红柿鸡蛋包子
四、线程池
4.1 线程池概述
各位小伙伴,接下来我们学习一下线程池技术。先认识一下什么是线程池技术? 其实,线程池就是一个可以复用线程的技术。
要理解什么是线程复用技术,我们先得看一下不使用线程池会有什么问题,理解了这些问题之后,我们在解释线程复用同学们就好理解了。
假设:用户每次发起一个请求给后台,后台就创建一个新的线程来处理,下次新的任务过来肯定也会创建新的线程,如果用户量非常大,创建的线程也讲越来越多。然而,创建线程是开销很大的,并且请求过多时,会严重影响系统性能。
而使用线程池,就可以解决上面的问题。如下图所示,线程池内部会有一个容器,存储几个核心线程,假设有3个核心线程,这3个核心线程可以处理3个任务。
但是任务总有被执行完的时候,假设第1个线程的任务执行完了,那么第1个线程就空闲下来了,有新的任务时,空闲下来的第1个线程可以去执行其他任务。依此内推,这3个线程可以不断的复用,也可以执行很多个任务。
所以,线程池就是一个线程复用技术,它可以提高线程的利用率。
4.2 创建线程池
在JDK5版本中提供了代表线程池的接口ExecutorService,而这个接口下有一个实现类叫ThreadPoolExecutor类,使用ThreadPoolExecutor类就可以用来创建线程池对象。
下面是它的构造器,参数比较多,不要怕,干就完了_。
接下来,用这7个参数的构造器来创建线程池的对象。代码如下
ExecutorService pool = new ThreadPoolExecutor(
3, //核心线程数有3个
5, //最大线程数有5个。 临时线程数=最大线程数-核心线程数=5-3=2
8, //临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行,就会被销毁掉。
TimeUnit.SECONDS,//时间单位(秒)
new ArrayBlockingQueue<>(4), //任务阻塞队列,没有来得及执行的任务在,任务队列中等待
Executors.defaultThreadFactory(), //用于创建线程的工厂对象
new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);
关于线程池,我们需要注意下面的两个问题
-
临时线程什么时候创建?
新任务提交时,发现核心线程都在忙、任务队列满了、并且还可以创建临时线程,此时会创建临时线程。
-
什么时候开始拒绝新的任务?
核心线程和临时线程都在忙、任务队列也满了、新任务过来时才会开始拒绝任务。
4.3 线程池执行Runnable任务
创建好线程池之后,接下来我们就可以使用线程池执行任务了。线程池执行的任务可以有两种,一种是Runnable任务;一种是callable任务。下面的execute方法可以用来执行Runnable任务。
先准备一个线程任务类
public class CuoZao implements Runnable{
@Override
public void run() {
// 任务 是搓澡
System.out.println("号码为:"+Thread.currentThread().getName()+" 的师傅,正在给客人搓澡====>盐搓 醋搓");
//模拟搓澡时间
try {
Thread.sleep(7000);//7秒 搓好一个人
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
下面是执行Runnable任务的代码,注意阅读注释,对照着前面的7个参数理解。
public class PoTianZaoTang {
public static void main(String[] args) throws InterruptedException {
//创建一个线程池 表示 每一个线程 是一个 搓澡人员
ExecutorService pool = new ThreadPoolExecutor(
3,// 核心搓澡师傅 3个 核心线程数
5,// 最多有五个 3个正式+2个临时 最大线程数
8, // 临时线程存活时间
TimeUnit.SECONDS, // 最多有8秒 摸鱼,超过8秒 开了临时的
new ArrayBlockingQueue<>(5),//任务阻塞队列 可以排队的人数 没来得及搓澡 而排队的客人
Executors.defaultThreadFactory(), //线程的创建工程 死的
//拒绝策略 忙不过来 交给main线程 忙不过老板上
new ThreadPoolExecutor.CallerRunsPolicy()
);
// 执行任务
//创建搓澡任务
CuoZao cz = new CuoZao();
pool.execute(cz);// 核心
pool.execute(cz);// 核心
pool.execute(cz);// 核心
pool.execute(cz);// 等待 核心搓完
pool.execute(cz);//等待
pool.execute(cz);//等待
pool.execute(cz);//等待
pool.execute(cz);//等待
// 核心3 忙碌 -- 任务阻塞队列 5 +1
pool.execute(cz);//等待
pool.execute(cz);//等待
// 5+5 核心+临时 已经在忙了 队伍也满了 老板上 拒绝策略是老板上
pool.execute(cz);//等待
Thread.sleep(17000);
System.out.println("已经空闲了10秒了 会开掉 两个师傅 留下三个师傅");
pool.execute(cz);// 核心
pool.execute(cz);// 核心
pool.execute(cz);// 核心
pool.execute(cz);// 等待 核心搓完
pool.execute(cz);//等待
//可以关闭线程池
// pool.shutdown();//都搓完了 在关闭
// pool.shutdownNow();//立马 关闭 没搓完 不搓了
}
}
执行上面的代码,结果输出如下
4.4 线程池执行Callable任务
接下来,我们学习使用线程池执行Callable任务。callable任务相对于Runnable任务来说,就是多了一个返回值。
执行Callable任务需要用到下面的submit方法
先准备一个Callable线程任务
public class MyCallable implements Callable<Integer> {
private Integer number;//定义了成员变量
public MyCallable(Integer number){//怎么把接收到number传递到 下面call方法中
this.number = number;//传过来的值 给了 成员变量
}
// 求一个数的绝对值
@Override
public Integer call() throws Exception {
System.out.println("当前在:"+Thread.currentThread().getName()+"完成绝对值的获取");
return Math.abs(number); //使用到了成员变量
}
}
再准备一个测试类,在测试类中创建线程池,并执行callable任务。
public class ShuXueAiTang {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//创建一个线程池 表示 每一个线程 回答的一个问题
ExecutorService pool = new ThreadPoolExecutor(
3,
5,
8,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(5),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy()
);
// 执行提交 callable任务
Future<Integer> f1 = pool.submit(new MyCallable(-10));
Future<Integer> f2 = pool.submit(new MyCallable(-1));
Future<Integer> f3 = pool.submit(new MyCallable(100));
Future<Integer> f4 = pool.submit(new MyCallable(0));
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());
//可以关闭线程池
// pool.shutdown();//都搓完了 在关闭
// pool.shutdownNow();//立马 关闭 没搓完 不搓了
}
}
执行后,结果如下图所示
4.5 线程池工具类(Executors)
有同学可能会觉得前面创建线程池的代码参数太多、记不住,有没有快捷的创建线程池的方法呢?有的。Java为开发者提供了一个创建线程池的工具类,叫做Executors,它提供了方法可以创建各种不能特点的线程池。如下图所示
接下来,我们演示一下创建固定线程数量的线程池。这几个方法用得不多,所以这里不做过多演示,同学们了解一下就行了。
public class ThreadPoolTest {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//创建一个线程池 传递一个参数
ExecutorService pool = Executors.newFixedThreadPool(3);
// 执行提交 callable任务
Future<Integer> f1 = pool.submit(new MyCallable(-10));
Future<Integer> f2 = pool.submit(new MyCallable(-1));
Future<Integer> f3 = pool.submit(new MyCallable(100));
Future<Integer> f4 = pool.submit(new MyCallable(0));
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());
//可以关闭线程池
// pool.shutdown();//都搓完了 在关闭
// pool.shutdownNow();//立马 关闭 没搓完 不搓了
}
}
Executors创建线程池这么好用,为什么不推荐同学们使用呢?原因在这里:看下图,这是《阿里巴巴Java开发手册》提供的强制规范要求。
五、补充知识
最后,我们再补充几个概念性的知识点,同学们知道这些概念什么意思就可以了。
5.1 并发和并行
先学习第一个补充知识点,并发和并行。在讲解并发和并行的含义之前,我们先来了解一下什么是进程、线程?
- 正常运行的程序(软件)就是一个独立的进程
- 线程是属于进程,一个进程中包含多个线程
- 进程中的线程其实并发和并行同时存在(继续往下看)
我们可以打开系统的任务管理器看看(快捷键:Ctrl+Shfit+Esc),自己的电脑上目前有哪些进程。
知道了什么是进程和线程之后,接着我们再来学习并发和并行的含义。
首先,来学习一下什么是并发?
进程中的线程由CPU负责调度执行,但是CPU同时处理线程的数量是优先的,为了保证全部线程都能执行到,CPU采用轮询机制为系统的每个线程服务,由于CPU切换的速度很快,给我们的感觉这些线程在同时执行,这就是并发。(简单记:并发就是多条线程交替执行)
接下,再来学习一下什么是并行?
并行指的是,多个线程同时被CPU调度执行。如下图所示,多个CPU核心在执行多条线程
最后一个问题,多线程到底是并发还是并行呢?
其实多个线程在我们的电脑上执行,并发和并行是同时存在的。
5.2 线程的生命周期
接下来,我们学习最后一个有关线程的知识点,叫做线程的生命周期。所谓生命周期就是线程从生到死的过程中间有哪些状态,以及这些状态之间是怎么切换的。
为了让大家同好的理解线程的生命周期,先用人的生命周期举个例子,人从生到死有下面的几个过程。在人的生命周期过程中,各种状态之间可能会有切换,线程也是一样的。
接下来就来学习线程的生命周期。在Thread类中有一个嵌套的枚举类叫Thread.Status,这里面定义了线程的6中状态。如下图所示
NEW: 新建状态,线程还没有启动
RUNNABLE: 可以运行状态,线程调用了start()方法后处于这个状态
BLOCKED: 锁阻塞状态,没有获取到锁处于这个状态
WAITING: 无限等待状态,线程执行时被调用了wait方法处于这个状态
TIMED_WAITING: 计时等待状态,线程执行时被调用了sleep(毫秒)或者wait(毫秒)方法处于这个状态
TERMINATED: 终止状态, 线程执行完毕或者遇到异常时,处于这个状态。
这几种状态之间切换关系如下图所示
先的,为了保证全部线程都能执行到,CPU采用轮询机制为系统的每个线程服务,由于CPU切换的速度很快,给我们的感觉这些线程在同时执行,这就是并发。(简单记:并发就是多条线程交替执行)
接下,再来学习一下什么是并行?
并行指的是,多个线程同时被CPU调度执行。如下图所示,多个CPU核心在执行多条线程
[外链图片转存中…(img-VwBNdGO2-1708689288965)]
最后一个问题,多线程到底是并发还是并行呢?
其实多个线程在我们的电脑上执行,并发和并行是同时存在的。
5.2 线程的生命周期
接下来,我们学习最后一个有关线程的知识点,叫做线程的生命周期。所谓生命周期就是线程从生到死的过程中间有哪些状态,以及这些状态之间是怎么切换的。
为了让大家同好的理解线程的生命周期,先用人的生命周期举个例子,人从生到死有下面的几个过程。在人的生命周期过程中,各种状态之间可能会有切换,线程也是一样的。
[外链图片转存中…(img-4lqZcQm9-1708689288966)]
接下来就来学习线程的生命周期。在Thread类中有一个嵌套的枚举类叫Thread.Status,这里面定义了线程的6中状态。如下图所示
[外链图片转存中…(img-HNJ6Un9l-1708689288968)]
NEW: 新建状态,线程还没有启动
RUNNABLE: 可以运行状态,线程调用了start()方法后处于这个状态
BLOCKED: 锁阻塞状态,没有获取到锁处于这个状态
WAITING: 无限等待状态,线程执行时被调用了wait方法处于这个状态
TIMED_WAITING: 计时等待状态,线程执行时被调用了sleep(毫秒)或者wait(毫秒)方法处于这个状态
TERMINATED: 终止状态, 线程执行完毕或者遇到异常时,处于这个状态。
这几种状态之间切换关系如下图所示
[外链图片转存中…(img-AeawKGE8-1708689288969)]