0


多线程编程——基础语法篇

多线程编程

文章目录

一、Thread

Thread

类是java标准库里面的类,表示的是线程,每个创建的Thread实例都是和系统中的一个线程是对应的。

Thread的用法有很多,接下来一一介绍:

1.1 Thread用法一

创建一个子类,继承自Thread,重写Thread中的run方法,run方法内部就包含了这个线程要执行的代码(每个线程都是独立的生产线,要执行一些代码)

// 标准库里提供了一个 Thread 这个类. 就使用这个类来表示线程.// 这个样子没有真正创建出线程来classMyThread1extendsThread{@Overridepublicvoidrun(){System.out.println("hello Thread!!");}}publicclassDemo1{publicstaticvoidmain(String[] args){// 真正创建出这个线程要做两步:// 1、创建 Thread 实例,此处是MyThread1这个实例对象;MyThread1 t =newMyThread1();// 2、调用Thread里面的.start() 方法,才是真正在系统内部创建出线程!!
        t.start();}}
.start()

的方法就会在系统中创建出新的线程出来,新的线程就是会执行子类里面的

run()

方法中的代码。

main 方法本身默认也是会执行出一个线程的(一个进程中不可能有一个线程都没有,至少得有一个线程),以往的代码中,每个代码的main方法,都对应出一个线程来,现在通过 t.start(),又创建出一个新的线程出来。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QuyLnOPU-1653197832759)(https://cdn.jsdelivr.net/gh/power152/Image/202205052030518.png)]

我们这里也可以在main方法中打印日志看一看他们是否是并发执行的。

classMyThread2extendsThread{@Overridepublicvoidrun(){while(true){System.out.println("hello thread!");try{Thread.sleep(1000);}catch(InterruptedException e){
                e.printStackTrace();}}}}publicclassDemo2{publicstaticvoidmain(String[] args){// 主线程MyThread2 t =newMyThread2();
        t.start();while(true){System.out.println("hello main!!");try{Thread.sleep(1000);}catch(InterruptedException e){
                e.printStackTrace();}}}}
Thread.sleep(1000);

我们这里用到了sleep这个方法,这里面的方法单位是 ms,sleep操作也可以叫做“休眠”,调用了sleep,该线程就暂时 relax ,不干活,在这休息期间线程也不会占用CPU,不会继续执行后续命令。

为什么使用

sleep

因为 while(true)死循环太快了,电脑吃不消,让两个线程同时休息1秒,再执行,相对来说对电脑要好一点。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SaHLkkZA-1653197832761)(https://cdn.jsdelivr.net/gh/power152/Image/202205052056457.png)]

有图可知,这两个线程的打印是交替进行的,交替进行也可说明,两个线程是

并发执行

的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nm88QzyN-1653197832761)(https://cdn.jsdelivr.net/gh/power152/Image/202205052103892.png)]

但是这里面的并发,并不是完全是“交替”,偶尔也会出现,我两条,你一条的情况,或者我一条,你两条的情况。

多线程之间执行的先后顺序,是不能完全确定的。当1秒过后,系统到底该执行那个线程,是不确定的。(这取决于操作系统内部调度代码的具体实现)。如果多个线程之间没有手动的控制先后顺序,那么就会认为多个线程之间执行的是“随机顺序”。这个“随机顺序”特别不稳定,容易出现BUG。

  • 给大家推荐一个JDK自带的 jconsole 工具,这个工具更直观的看到两个代码中的线程,在自己的安装的 JDK 的bin目录下。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f9fJIOhK-1653197832762)(https://cdn.jsdelivr.net/gh/power152/Image/202205052135996.png)]

  • 用法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eqUaNXPW-1653197832764)(https://cdn.jsdelivr.net/gh/power152/Image/202205052145121.png)]

1.2、Thread用法二 (Runnable)

创建类,实现

Runnable

接口。Runnable接口也是标准库中自带的一个接口,也是要重写run()方法。

创建 Thread 实例,然后把刚才的 Runnable 实例给 设置进去。

packagethread;classMyRunnableimplementsRunnable{@Overridepublicvoidrun(){// 描述了任务具体要执行的任务while(true){System.out.println("hello thread!!");try{Thread.sleep(1000);}catch(InterruptedException e){
                e.printStackTrace();}}}}publicclassDemo3{publicstaticvoidmain(String[] args){Thread t =newThread(newMyRunnable());
        t.start();while(true){System.out.println("hello main!");try{Thread.sleep(1000);}catch(InterruptedException e){
                e.printStackTrace();}}}}

这种写法,是通过 实现 Runnable 实现的,(通过 Runnable 这种方式,相当于把 “要执行的任务” 和 Thread 类,进行分离(解耦合);用法一的写法是 继承 Thread 实现的。

1.3、Thread用法三

这种写法是匿名内部类;

packagethread;publicclassDemo4{// 匿名内部类的方法publicstaticvoidmain(String[] args){// 父类引用指向了子类的对象 -------- 多态// 创建一个匿名的子类,继承自 Thread 父类Thread t =newThread(){@Overridepublicvoidrun(){while(true){System.out.println("hello thread!!");try{Thread.sleep(1000);}catch(InterruptedException e){
                        e.printStackTrace();}}}};
        t.start();while(true){System.out.println("hello main");try{Thread.sleep(1000);}catch(InterruptedException e){
                e.printStackTrace();}}}}

1.4、Thread用法四

创建了一个Runnable的匿名内部类,匿名内部类中实现 run()方法,描述任务,Thread并创建出实例,直接交给 Thread 来进行使用。

publicclassDemo5{publicstaticvoidmain(String[] args){Thread t =newThread(newRunnable(){@Overridepublicvoidrun(){while(true){System.out.println("hello thread");try{Thread.sleep(1000);}catch(InterruptedException e){
                       e.printStackTrace();}}}});
       t.start();while(true){System.out.println("hello main");try{Thread.sleep(1000);}catch(InterruptedException e){
               e.printStackTrace();}}}}

1.5、Thread用法五(lambda)

使用 lambda 表达式来使用

publicclassDemo6{publicstaticvoidmain(String[] args){// 重写的run()无参Thread t =newThread(()->{while(true){System.out.println("hello thread");try{Thread.sleep(1000);}catch(InterruptedException e){
                    e.printStackTrace();}}});
        t.start();while(true){System.out.println("hello main");try{Thread.sleep(1000);}catch(InterruptedException e){
                e.printStackTrace();}}}}

总结:

1、描述清楚要执行的任务是啥(

run()

方法)

2、把这个任务给加到一个Thread 实例中,并调用 start 方法。

二、run 和 start 的区别

run() 方法是一个普通的方法,只是会当做普通的方法执行,不会创建出新的线程出来,所以此时就只有一个 main线程,只有等到main线程中的run()方法调用执行完,才会执行第二个循环。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D0Nx8g51-1653197832765)(https://cdn.jsdelivr.net/gh/power152/Image/202205072120328.png)]

1、start()这个方法,只要一执行就会创建出一个新的线程出来,新线程就会执行run()方法,

2、run()方法自身不具备创建新线程的能力,仍然在旧的线程中执行。

三、并发编程有何用?

并发编程(多线程)最明显的优势,就是针对 ”CPU密集型“ 的程序,能提高效率。

1、”CPU密集型“:程序进行大量的运算

可以理解两个人干活的效率,总比一个人干活的效率高,但是提升的效率也不一定正好是减少 50% ,因为系统中不能保证两个线程是完全 并发 执行的。(尤其是系统资源本身比较紧张的情况下)

所以想要提升速度的话,可以考虑使用多线程进行任务拆分,提高效率。

并发编程追求目标,也就是通过多线程,可以更充分的利用多核CPU的计算资源。

四、Thread的方法和属性

一、

Thread(String name)

,通过

name

是可以给线程取名字的,方便程序员调试,

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cEQBEWbs-1653197832766)(https://cdn.jsdelivr.net/gh/power152/Image/202205072154641.png)]

可以打开

jconsole.exe

工具 confirm 一下,如果不取名字,JVM 默认会给指定的名字,形如 Thread-0,Thread-1…

关于进程的结束:

1、创建出来的是一个 非后台 线程,此时及时 main 线程执行完了,java的进程仍然要继续进行执行,等到所有的 非后台线程执行完,java的进程才会退出。

2、如果一个线程是 后台线程 ,此时后台线程就不会影响到 Java 进程的结束。

二、

IsAlive

1、这个属性和方法表示,Thread 变量 t,和操作系统内核中的线程,生命周期不是完全相同的;t被创建出来了,内核里面不一定有对应的线程,必须要通过 t.start() 来调用,才有对应的线程。

2、内核中的线程被销毁了(执行结束),t 不一定销毁, 内核线程的 run 方法执行完,也就结束了,t 要等到 GC 来进行释放。

拿到 t 变量,不能断言出内核里的对应线程也是同样存在的,只有通过 `IsAlive` 就是来判断:
a、true,说明内核的线程在
b、false,内核的线程已经执行完了,或者还没开始执行。

五、控制线程的具体操作

1、创建线程;.start()方法,这个之前就已经讲过了,不再赘述,主要掌握,.start() & run() 方法之间的区别就行。

5.2、中断线程(让线程结束):

​ run 方法执行完,线程随之就结束了。

​ 方法:(1)、强行终止进程,线程随之也就结束了;(特殊手段)

​ (2)、手动设置标志位,作为循环判断的条件;

publicclassDemo7{// 通过一个变量来控制线程是否结束privatestaticboolean isQuit =false;publicstaticvoidmain(String[] args){Thread t =newThread(()->{while(!isQuit){System.out.println("hell thread!!");try{Thread.sleep(1000);}catch(InterruptedException e){
                   e.printStackTrace();}}});
        t.start();try{Thread.sleep(5000);}catch(InterruptedException e){
            e.printStackTrace();}

        isQuit =true;}}

这里的

isQuit

是在t 线程读取,main线程修改。

(3)、借助 Thread 实例中自己提供的一个标志位

interrupt()

,不能直接引用标志位的变量,但是可以通过一些方法来进行 读和写的操作

​ a、通过 Thread 中的

isIntrrupted

方法来判定标志位是否为 true;(true表示线程应该退出)----读操作

​ b、通过 Thread 中的

interrupt

方法,来把这个标志位设为 true;(表示中断)--------写操作

publicclassDemo8{publicstaticvoidmain(String[] args){Thread t =newThread(){@Overridepublicvoidrun(){// 默认为falsewhile(!this.isInterrupted()){System.out.println("hello thread");try{Thread.sleep(1000);}catch(InterruptedException e){
                        e.printStackTrace();// catch 只是打印出异常,会继续执行,需要break跳出循环,来修改 interrupt 的值break;}}}};
        t.start();try{Thread.sleep(5000);}catch(InterruptedException e){
            e.printStackTrace();}// 进行修改,改成true,表示线程中断。
        t.interrupt();}}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q2N9XXZo-1653197832767)(https://cdn.jsdelivr.net/gh/power152/Image/202205081646781.png)]

由图可知如果没有加break,只会打印出异常,线程继续执行;

调用 interrupt 方法的时候,如果线程是“就绪状态”,此时是直接修改 线程中的标志位。如果是“阻塞状态”,此时会引起 InterruptedException 异常。

在 t 线程代码中,存在两种情况:

1、执行打印和 while 循环判定。(线程处于“就绪状态”)

2、进行sleep(线程处于“阻塞状态”)

5.3、等待线程(join)

等待指定的线程执行完。

such as:在main线程中,调用 t.join(),那么就是让main来等待 t 这个线程执行完毕。

当调用

join()

的时候,就会“阻塞等待”。效果类似于

sleep

publicclassDemo9{publicstaticvoidmain(String[] args){Thread t =newThread(()->{for(int i =0; i<5; i++){System.out.println("hello thread");try{Thread.sleep(1000);}catch(InterruptedException e){
                    e.printStackTrace();}}});
        t.start();System.out.println("main方法中 t 线程还没有执行完");try{
            t.join();}catch(InterruptedException e){
            e.printStackTrace();}System.out.println("t 线程执行完了");}}

代码执行到join就不再继续往下走了,会进入等待,直到 t 线程执行完 (t线程中的run方法结束),然后join才会继续。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-37NB0U3B-1653197832767)(https://cdn.jsdelivr.net/gh/power152/Image/202205221334965.png)]

作用:通过 join 可以控制线程结束的先后顺序 (手动控制,谁先谁后),在多线程之间调度的顺序是不确定的(抢占式),这种的不确定性会给代码添加很多的偶然性和随机性,就会让代码出现奇怪的bug。这里的 join 就是手动控制线程执行顺序的一种办法,join 主要是用来控制结束的顺序。
方法说明public void join()等待线程结束public void join(long millis)等待线程结束,最多等 millis 毫秒public void join(long millis, int nanos)同理,但可以更高精度
这里是带参数和不带参数的 join 方法,不带参数就是“死等”,带参数就是通过参数设置一个等待时间(ms),这个等待时间就表示join最多等多久(超时时间)。

5.4、获取当前线程的应用

在某个线程的代码中,拿到当前这个线程对应的 Thread 对象的引用;拿到这个引用才能做一些后续的操作,很多和线程相关的操作,都是依赖这样的引用。
方法说明public static Thread currentThread();返回当前线程对象的引用
1、如果是继承了 Thread 来创建了线程,此时直接在 run 方法中通过 this,就能拿到这个线程的实例。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DmtiQmPF-1653197832768)(https://cdn.jsdelivr.net/gh/power152/Image/202205221335440.png)]

2、但是我们有一个跟常键的方法是使用 Thread 里面的静态方法,currentThread(),上面也有提及,那个线程调用了这个静态的方法,就能够返回那个线程的 Thread 实例引用,这样的获取方法可以在任何方法中使用。

注意:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-48oJMcLC-1653197832768)(https://cdn.jsdelivr.net/gh/power152/Image/202205221335319.png)]

这里为什么会变红,因为我们是在Runnable方法里面调用的,因此此刻 this 这里指向的是 Runnable,所以就没有 Thread 类里面的方法和属性了

切记自己到底是引用的什么类,不管怎么说都要引用的是 Thread 的实例。

但是我们也有更好的解决方法,那就是使用我们的静态类,currentThread()!!!

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kIdMH9Kj-1653197832769)(https://cdn.jsdelivr.net/gh/power152/Image/202205221336987.png)]

此时,虽然run是 Runnable 方法,但是通过 Thread 的 currenThread() 来获取到线程的实例;

Thread.currentThread()

这个方法是在那个线程调用的,就返回那个线程的实例。

5.5、线程的休眠 sleep

调用线程的sleep方法,线程就会进行阻塞等待,等待的时间取决于 sleep 中指定的时间。

在一个进程中会有多个线程,每个线程都对应着一个PCB(不知道PCB是啥,点击这个链接了解),此时进程中就会有一组 PCB,操作系统就是以 PCB 为单位进行调度执行的。

而我们的 PCB 在进程中是以双向链表组织管理的,操作系统调度 PCB 的时候,就是从

就绪队列

中挑出一个 PCB 去CPU 上执行。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a8bmdTJl-1653197832770)(https://cdn.jsdelivr.net/gh/power152/Image/202205221336558.png)]

但是 sleep 相当于阻塞了,那么阻塞队列这边就会把就绪队列里面的一个PCB(链表)给移动到阻塞队列里面来,等到sleep等待的时间到了实际成熟了,这个PCB再回到就绪队列中。

区分:

像通过 sleep 产生的阻塞的操作,时机成熟 => 时间到了;

通过 join 产生的阻塞操作,时机成熟 => 对应的线程结束了

这里当sleep的时间到了 PCB 回到就绪队列里面并不会立即在 CPU 上面执行,那么什么时候 CPU 会调用回到就绪队列里面的PCB 就说不准了,因为操作系统调度线程是存在一定的随机性)。

五、线程的状态

线程里面的状态会更详细一些,java也是对线程进行了封装,并且也给出了一些具体的描述,多了解线程的状态是有用的,主要是调试一些多线程程序的时候,会用的上。

publicclassThreadState{publicstaticvoidmain(String[] args){for(Thread.State state :Thread.State.values()){System.out.println(state);}}}

这段代码就是把java线程里面的所有状态都打印出来, Thread.State 这是一个枚举类型。

  • NEW: 安排了工作, 还未开始行动
  • RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
  • BLOCKED: 这几个都表示排队等着其他事情
  • WAITING: 这几个都表示排队等着其他事情
  • TIMED_WAITING: 这几个都表示排队等着其他事情
  • TERMINATED: 工作完成了

虽然这上面有很多种状态,但是最关键的还是只有两种 就绪和阻塞 ,java线程的这些状态只是把这两个大类型的状态给细分了,

NEW:把 Thread 对象创建出来了,但是内核里面线程还没有创建出来 (没调用 start 方法)。

TERMINATED:内核里面的线程结束了,然而 Thread 对象还在。

RUNNABLE:就绪状态 (重要的一种状态)

TIMED_WAITING: 通过 sleep 产生的。

BLOCKED:等待锁产生的状态。(这也是阻塞,只不过是锁的阻塞,重要)

WAITING:通过 wait 方法触发,与锁有着密切的联系。(重要)

线程状态之间转换关系图:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fRQoGUvs-1653197832770)(C:\Users\15277\AppData\Roaming\Typora\typora-user-images\image-20220520233813947.png)]


这篇帖子介绍了多线程编程的基本用法和基础概念,都是必掌握,下一篇帖子更重要,关于”线程的安全“ ,这是整个多线程中最重要的关键点!!!

铁汁们,觉得笔者写的不错的可以点个赞哟❤🧡💛💚💙💜🤎🖤🤍💟,收藏关注呗,你们支持就是我写博客最大的动力!!!!

标签: java

本文转载自: https://blog.csdn.net/qq_54219272/article/details/124909759
版权归原作者 鸢也 所有, 如有侵权,请联系我们删除。

“多线程编程&mdash;&mdash;基础语法篇”的评论:

还没有评论