【JavaEE】——多线程(join阻塞,计算,引用,状态)

阿华代码,不是逆风,就是我疯,你们的点赞收藏是我前进最大的动力!!希望本文内容能够帮助到你!

目录

一:join等待线程结束

1:知识回顾

2:join的功能就是"阻塞等待"

3:谁调用谁等待

4:join和"优先级"区分

二:多线程运行计算

1:情景引入

2:多线程提升进程的运行效率

(1)代码分析

3:串行执行

三:获取线程的引用

1:Thread.currentThread():

2:创建线程方式影响this引用

3:代码举例如下

四:线程的状态

0:.getState()

[1: NEW](#1: NEW)

2:TERMINATED

3:RUNNABLE

4:TIME_WAITING

5:WAITING

6:BLOCK


引入:通过上一篇文章的学习,我们知道可以通过用Thred的sleep方法,让main函数这个线程进行沉睡,进而达到,让其它线程先执行完毕,main函数在执行这种目的。但是如果不清楚其他线程何时结束,就不能使用sleep方法了

一:join等待线程结束

1:知识回顾

(1)多线程的调度是无序的(随机调度,抢占式执行)

(2)可以通过操作系统提供的一系列api来控制线程的执行顺序

2:join的功能就是"阻塞等待"

如果t1这个线程还在运行,main函数就必须等着,这就是"阻塞等待"。(可以理解成插队,我join到你前面了,一定是我先买到票走人)(阅读以下代码加深理解)

3:谁调用谁等待

因为实在main函数中,t1join进去的,所以main函数等待。如果现在有t1,t2,两个线程都join了呢?------t1 , t2 并发执行,随机调度,两者都执行完毕了,main函数才能执行

4:join和"优先级"区分

join不是确定"执行顺序"而是确定"结束顺序",本质是让调用操作系统的api进行控制,让main函数放弃去"调度器"中调度。

java 复制代码
package thread;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-09-20
 * Time: 20:34
 */
public class ThreadDemon14 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                System.out.println("t1线程正在运行");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t1.start();
        t1.join();
        System.out.println("这里是main函数线程,我需要等待t1线程执行完毕,才能进行打印");
    }
}

二:多线程运行计算

1:情景引入

问题:我们用单线程和多线程去计算前1_0000_0000个数字之和,看两者速度差多少

2:多线程提升进程的运行效率

(1)代码分析

下面第一个代码------兵分三路:①main,②算1~5000_0000 ,③算5000_0001~1_0000_0000。本质上来说是 (并发执行=并行+并发) ②③在不同的核心上(并行) ,②③同时运行(并发)

不懂得可以看我前面写过的文章哦!有举例子。

java 复制代码
package thread;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-09-19
 * Time: 14:13
 */
public class ThreadDemon15 {
    private static long result = 0;
    public static void main(String[] args) throws InterruptedException {
        //用多线程去计算前多少个数字之和
        Thread thread = new Thread(()->{
               long tem = 0;
            for (long i = 0; i < 5000_0000L; i++) {
                tem += i ;
            }
            result += tem ;
        });
        Thread thread2 = new Thread(()->{
            //thread.join();//又变成了串行执行了,并非并发执行
            long tem = 0;
            for (long i = 5000_0001 ; i < 1_0000_0000L ; i++) {
                tem += i;
            }
            result += tem;
        });


        thread.start();//创建一个新的线程,新的线程跟之前的线程是"并发执行"的关系
        thread2.start();
        long beg = System.currentTimeMillis();//记录开始时间
        //main函数线程阻塞,等待thread线程运行


        thread.join();
        thread2.join();//确保thread进程执行完毕在执行main函数

        long end = System.currentTimeMillis();//记录结束时间

        System.out.println("双线程的计算结果是:" + result);
        System.out.println("双线程用到的时间是:" + (end - beg) );


    }
}
java 复制代码
package thread;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-09-20
 * Time: 21:03
 */
public class ThreadDemon15_2 {
    private static long result = 0;
    public static void main(String[] args) throws InterruptedException {
        //用多线程去计算前多少个数字之和
        Thread thread = new Thread(()->{
            long tem = 0;
            for (long i = 0; i < 1_0000_0000L; i++) {
                tem += i ;
            }
            result += tem ;
        });

        thread.start();//创建一个新的线程,新的线程跟之前的线程是"并发执行"的关系
        long beg = System.currentTimeMillis();//记录开始时间
        //main函数线程阻塞,等待thread线程运行

        thread.join();

        long end = System.currentTimeMillis();//记录结束时间

        System.out.println("单线程的计算结果是:" + result);
        System.out.println("单线程用到的时间是:" + (end - beg) );


    }
}

3:串行执行

有没有办法让第一个线程结束,在进行第二个线程,最后执行main函数

三:获取线程的引用

1:Thread.currentThread():

获取到当前线程的引用(Thread引用)

2:创建线程方式影响this引用

如果继承的是Thread类,那么可以用this拿到线程的引用

如果是Runnable或者lambda的方式创建线程,this不能指向Thread对象了,那么此时this就不可以用了,就只能使用Thread.currentThread。

3:代码举例如下

java 复制代码
package thread;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-09-19
 * Time: 16:18
 */
class MyThread5 extends Thread{
    @Override
    public void run() {
        System.out.println(this.getId() + "," + this.getName());
    }
}
public class ThreadDemon16 {
    public static void main(String[] args) throws InterruptedException {
        /*
        * t1,t2 的先后顺序是不确定的,线程的随机调度*/
        Thread t1 = new MyThread5();
        Thread t2 = new MyThread5();
        t1.start();
        t2.start();
        Thread.sleep(1000);

        System.out.println(t1.getId() + t1.getName());
        System.out.println(t2.getId() + t2.getName());

    }

}
java 复制代码
package thread;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-09-19
 * Time: 16:27
 */
public class ThreadDemon17 {
    /*
    * 使用lambda表达式和Runnable接口写法,就不能用this了
    *lambda中没有指向任何对象,this没法用
    * Runnable写法则是this指向的是Runnable
    * 所以只能用.currentThread这个方法来获取当前*/
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            Thread t = Thread.currentThread();
            System.out.println(t.getId()+t.getName());
        });

        Thread t2 = new Thread(()->{
           Thread t = Thread.currentThread();
            System.out.println(t.getId()+t.getName());
        });
        t1.start();
        t2.start();
    }

}

四:线程的状态

通过之前的学习,我们知道线程有就绪和阻塞两种状态。下面我们进行更深入的学习

0:.getState()

获取线程的状态

1: NEW

创建了Thread对象,但是还没有调用start方法,线程还没有运行起来

2:TERMINATED

terminated终止状态,一个线程已经执行完毕,但是Thread对象还存在,

3:RUNNABLE

runnable状态,线程正在cpu上运行,或者准备就绪,随时可以上cpu运行

4:TIME_WAITING

time_waiting状态, 多为sleep和join引起的带有一定时间的阻塞等待

5:WAITING

waiting状态,(线程死等),多为wait和join引起

6:BLOCK

block状态,由锁竞争引起的阻塞

java 复制代码
/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Hua YY
 * Date: 2024-09-19
 * Time: 16:58
 */
public class ThreadDemon18 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 3; i++) {
                System.out.println("线程正在运行");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

            }
        });
        System.out.println("t1为NEW状态:"+t1.getState());
        t1.start();//开始执行线程
        System.out.println("t1是RUNNABLE状态" + t1.getState());
        t1.join();//main等待t1线程执行完毕         //想要获取WAITING状态把这一行屏蔽掉
        Thread.sleep(500);//这里是确保让下一句不要那么快执行,正好让 Thread在sleep(1000)的期间获取状态
        System.out.println("t1是TERMINATED状态"+t1.getState());
    }
}

相关推荐
芊寻(嵌入式)8 分钟前
C转C++学习笔记--基础知识摘录总结
开发语言·c++·笔记·学习
WaaTong9 分钟前
《重学Java设计模式》之 原型模式
java·设计模式·原型模式
m0_743048449 分钟前
初识Java EE和Spring Boot
java·java-ee
AskHarries11 分钟前
Java字节码增强库ByteBuddy
java·后端
一颗松鼠17 分钟前
JavaScript 闭包是什么?简单到看完就理解!
开发语言·前端·javascript·ecmascript
泉崎17 分钟前
11.7比赛总结
数据结构·算法
有梦想的咸鱼_18 分钟前
go实现并发安全hashtable 拉链法
开发语言·golang·哈希算法
你好helloworld19 分钟前
滑动窗口最大值
数据结构·算法·leetcode
海阔天空_201324 分钟前
Python pyautogui库:自动化操作的强大工具
运维·开发语言·python·青少年编程·自动化
天下皆白_唯我独黑31 分钟前
php 使用qrcode制作二维码图片
开发语言·php