java线程之Thread类的基本用法

痛定思痛。 2023-09-25 17:26 51阅读 0赞

### Thread类的基本用法 ###

*  1. Thread类的构造方法
 *  2. Thread的几个常见属性
 *   *  常见属性
     *  线程中断
     *  等待一个线程

小鱼在上一篇博客详细的讲解了如何创建线程,java使用Thread类来创建多线程,但是对于好多没有相关经验的人来说,比较不容易理解的地方在于操作系统调度的执行过程. 我们通过下面代码举例:

public static void main(String[] args) {
        
            Thread t = new Thread(() -> {
        
                System.out.println("hello t");
            });
            //调用start(),创建一个新的线程
            t.start();
     
            System.out.println("hello main");
        }

我们的java在启动时,会创建一个主线程,此时主线程的名字就是main,接下来我们执行main线程里面的一条条代码了,当我们执行到t.start()时,系统就会自动帮我们创建一个新的线程,并且会自动帮我们调用该线程中的run()方法,此时的run()方法就可以认为是个入口,一些重要的实现逻辑将都在里面实现.

我们通过上述代码举例:

当我们实例一个thread并且调用start()方法之后, main 线程和 t 线程就是(并发+并行)的过程,由于多线程有一个**万恶之源–抢占机制**,所以就会导致我们无法预测到程序是优先执行"hello t" 还是 “hello main”,并且对于谁先结束线程的任务,我们也是不确定的,可能是main线程优先结束,也可能是t线程优先结束.

![在这里插入图片描述][051fef385ec344b6a2f00bd74429b59f.png]

创建线程是看start的顺序，但是具体的线程对应的任务什么时候执行，要看系统调度器。

# 1. Thread类的构造方法 #

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Thread()</td> 
   <td>创建线程对象</td> 
  </tr> 
  <tr> 
   <td>Thread(Runnable target)</td> 
   <td>使用Runnable对象创建线程对象</td> 
  </tr> 
  <tr> 
   <td>Thread(String name)</td> 
   <td>创建线程对象并命名</td> 
  </tr> 
  <tr> 
   <td>Thread(Runnable target,String name)</td> 
   <td>使用Runnable对象创建线程对象，并命名</td> 
  </tr> 
  <tr> 
   <td>Thread(ThreadGroup group,Runnable target)</td> 
   <td>线程可以被用来分组管理，分好的组即为线程组</td> 
  </tr> 
 </tbody> 
</table>

关于构造方法的讲解在这篇文章中详细的讲到了,包括如何创建一个线程,以及创建线程需要注意的事项都在这里一一列举了出来[多线程的创建及其注意事项][Link 1]

# 2. Thread的几个常见属性 #

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>获取方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ID</td> 
   <td>getId()</td> 
  </tr> 
  <tr> 
   <td>名称</td> 
   <td>getName()</td> 
  </tr> 
  <tr> 
   <td>状态</td> 
   <td>getState()</td> 
  </tr> 
  <tr> 
   <td>优先级</td> 
   <td>getPriority()</td> 
  </tr> 
  <tr> 
   <td>是否后台线程</td> 
   <td>isDaemon()</td> 
  </tr> 
  <tr> 
   <td>是否存活</td> 
   <td>isAlive()</td> 
  </tr> 
  <tr> 
   <td>是否被中断</td> 
   <td>isInterrupted()</td> 
  </tr> 
 </tbody> 
</table>

## 常见属性 ##

(1) **getid()** : ID表示线程的身份.就类似于我们的身份证一样,是独一无二的.这里的方法获取到的是线程在JVM中的身份标识,线程的标识有好多个,在内核的PCb上有标识,在用户态线程数据库中也有标识(操作系统的线程库)

(2) **getName()** : 获取当前线程的名字,多用于调试时使用.

(3) **getState()** :获取当前线程的状态,状态表示线程当前所属的一个情况.

(4) **getPriority()** : 优先级高的线程理论上来说更容易被调度到，但实际上并没有什么区别.大概可以理解为,你建议我不要晚睡,但也仅仅是建议,我可以不听.

(5) **isDaemon()** :daemon称为"守护线程",也可以称为后台线程,如果是后台线程就会返回`true`,前台线程则是`false`,我们可以这么理解后台线程,当我们手机打开qq这个app时,此时qq就是前台运行,但是由于我们后续可能会切换到快手app,此时qq就来到后台运行了.

一个线程创建出现**默认是前台线程**,前台线程会阻止**进程的退出**,进程只有在所有的前台线程都执行完之后才可以退出,但是对于后台进程,并不会阻止进程的结束.

**JVM会在一个进程的所有非后台进程结束后，才会结束运行。**

(6)**isAlive()** : 是否存活，即run()方法是否结束。

public class Demo4 {
        
        public static void main(String[] args) {
        
            Thread t = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("t 线程正在运行");
                }
            });
            System.out.println("t线程是否存活 "+t.isAlive());
            t.start();
            System.out.println("t线程是否存活 "+t.isAlive());
    
            try {
        
                Thread.sleep(1000);
                System.out.println("t线程是否存活 "+t.isAlive());
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
        }
    }

> 如果 t 的run还没跑，isAlive就为false；  
> 如果 t 的run正在跑，isAlive就为true；  
> 如果 t 的run跑完了，isAlive就为false；

执行结果:

![在这里插入图片描述][acfbd778ae144c91a305560612a995c0.png]

此时我们将上述涉及到的属性的状态打印出来:

![在这里插入图片描述][64ccb579eb7e46e984c267e9695068d7.png]

使用setDaemon(布尔值)方法设置一个线程为后台，true表示后台线程。

class MyThread1 extends Thread{
        
        @Override
        public void run() {
        
            System.out.println("hello  t");
        }
    }
    public class Demo1 {
        
        public static void main(String[] args) {
        
            Thread t = new MyThread1();
            t.start();
    
            System.out.println("hello main");
            try {
        
                Thread.sleep(1000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            //设置为后台线程
            t.setDaemon(true);
            System.out.println("是否是后台线程 "+ t.isDaemon());
        }
    }

执行结果:

![在这里插入图片描述][5a72a52913ba4117af1d0df9bbf64c54.png]  
上述操作都是获取到的一瞬间的状态，不是持续的状态。

**start()和run()方法的区别:**

> 当我们调用start()这个方法时,创建一个新的线程(有一个向系统创建一个线程的这么一个动作),此时这个线程会由系统自动调用**run()方法**(入口方法).并且这个run()方法是在这个新建的线程中运行的.  
> 但是如果是程序员手动调用run()方法的话,并不会新建一个线程,并且该方法是在调用这个方法的线程中执行的.

**获取当前线程的引用:**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static Thread currentThread();</td> 
   <td>返回当前线程对象的引用</td> 
  </tr> 
 </tbody> 
</table>

public static void main(String[] args) {
        
     		//获取当前线程的引用
            Thread t = Thread.currentThread();
            //通过当前线程的引用调用当前线程的名字
            System.out.println("当前线程名字 : "+t.getName());
        }

执行结果:  
![在这里插入图片描述][9bc16898e0b14895b5262fcf3373d253.png]

**休眠当前线程**:

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static void sleep(long millis) throws InterruptedException</td> 
   <td>休眠当前线程 millis毫秒</td> 
  </tr> 
  <tr> 
   <td>public static void sleep(long millis, int nanos) throwsInterruptedException</td> 
   <td>可以更高精度的休眠</td> 
  </tr> 
 </tbody> 
</table>

public static void main(String[] args) {
        
            Thread t = new Thread(()->{
        
                System.out.println("hello t");
            });
            t.start();
            try {
        
                //睡眠1000ms,也可以称为阻塞1000ms
                 Thread.sleep(1000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("hello main");
        }

睡眠的状态就相当于这个线程被**阻塞**了,阻塞的时间由里面的参数决定,在这个线程阻塞的时间并不影响其他线程执行,可以理解为~我们在打游戏,打着打着未成年时间限制弹了出来,这时候就要求我们停止打游戏这个行为,只有等这个等待时间过去之后才可以继续打游戏.

**注**:等待的过程中什么都不能做,相当于被定身了一样!!!

## 线程中断 ##

中断线程，就是让线程尽快的把入口方法(run方法)执行结束。有2种方法。

(1) 直接手动创建标志位来区分线程是否要结束.

public class ThreadDemo5 {
        
        static boolean flog = true;
        public static void main(String[] args)  {
        
            Thread t = new Thread(()->{
        
               while (flog){
        
                   try {
        
                       Thread.sleep(500);
                   } catch (InterruptedException e) {
        
                       e.printStackTrace();
                   }
                   System.out.println("线程运行中~~");
               }
                System.out.println("t 线程结束");
            });
            t.start();
            try {
        
                //睡眠3000ms
                Thread.sleep(3000);
                //将标志位设置为false终止上面的while()
                System.out.println("控制新线程结束");
                flog = false;
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

运行结果:

![在这里插入图片描述][6f18ff4425d44c65ad8b7f339e6e599b.png]  
有些线程可能会存在一些循环需要执行的情况,但是可能只是需要执行一定时间,并不是一直执行,所以就可以通过sleep()来控制这个线程结束的时间.

需要注意的是:flog需要是成员变量,局部变量是线程私有的,其余线程不能进行修改,但是成员变量是处于进程的数据区,是共享的资源,所以可以访问和修改~~

Thread内置了标志位，不需要手动创建标志位。

**（2）Thread内置的标志位**

public class ThreadDemo5 {
        
        static boolean flog = true;
        public static void main(String[] args)  {
        
            Thread t = new Thread(()->{
        
               while (!Thread.currentThread().isInterrupted()){
        
                   try {
        
                       Thread.sleep(500);
                   } catch (InterruptedException e) {
        
                       e.printStackTrace();
                   }
                   System.out.println("线程运行中~~");
               }
                System.out.println("t 线程结束");
            });
            t.start();
            try {
        
                //睡眠3000ms
                Thread.sleep(3000);
                //将标志位设置为false终止上面的while()
                System.out.println("控制新线程结束");
               t.interrupt();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

![在这里插入图片描述][69703eb0eee243d28a617db1b30b791a.png]  
Thread.currentThread().这个是Thread类的静态方法，通过这个方法可以获取当前线程，类似this；

isInterrupted()方法是一个判定内置的标志位，**默认是false，true表示线程要中断**。现在运行，查看结果。

![在这里插入图片描述][b236c29cfc344954ad9d4347842e1879.png]

为什么在抛出异常后线程还是在不停的执行呢?

那是因为当代码执行到interrupt()时会做两件事:

(1) 如果t 线程没有处于阻塞状态时,这时候interrupt()就会修改内置标志位,将isInterrupted的状态设置为true;

(2) 如果 t 线程处于阻塞状态时,此时`interrupt()`会通过触发异常,将阻塞状态(sleep)提前唤醒,但是由于把sleep唤醒会导致标志位变成false,也就是将标志位清空,如果标志位本身就是false则不变.由于我们的循环条件是`while(!Thread.currentThread().isInterrupted())`,又因为我们的标志位又变成了false,所以我们可以继续执行这个循环.

实际中能产生阻塞的方法有很多,并不是只有sleep,这里只是用sleep举例子.

由于计算机的执行速度时很快的,所以阻塞状态大概占线程执行状态的99.99%,所以会有更大的几率触发(2).

当然,即使是大部分时间都在阻塞状态,但是该线程始终是在阻塞状态和正常运行的状态之间切换.

当然,我们可以通过**break**关键字,当抛出异常时直接break就可以不再执行循环,之后就可以结束线程,这就相当于我正在打游戏,我妈喊我吃饭,此时我不敢抗拒,只能去吃饭.

代码如下:

public class ThreadDemo5 {
        
        public static void main(String[] args)  {
        
            Thread t = new Thread(()->{
        
               while (!Thread.currentThread().isInterrupted()){
        
                   try {
        
                       Thread.sleep(500);
                   } catch (InterruptedException e) {
        
                       e.printStackTrace();
                        break;
                   }
                   System.out.println("线程运行中~~");
               }
                System.out.println("t 线程结束");
            });
            t.start();
            try {
        
                //睡眠3000ms
                Thread.sleep(3000);
                //将标志位设置为false终止上面的while()
                System.out.println("控制新线程结束");
               t.interrupt();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

此时的运行结果:

![在这里插入图片描述][35f5ac83fa6145fba6e629da6441abcd.png]  
当然,由于我们捕捉到了异常,我们不仅可以直接让他break,还可以让他先等待一会再结束执行.

就像我们在打电话一样:

比如我正在打游戏,女朋友让我出去买菜,此时我不搭理她,这个时候就相当于,你说你的我干我的.

但是呢?过了一会女朋友又来跟我说让我买菜去,我因为怕她生气嘛,所以我跟她说,五分钟,五分钟就好…等五分钟一到,我就退出游戏买菜去了.

当我买完菜的时候,刚躺到床上打开游戏,此时厨房传来女朋友的尖叫声,那我必须立刻放下手机去看看发生了什么事情…

总结三种状态;(1)立即退出 (2) 等待一会再退出 (3) 不退出,你说你的我做我的.

**由我们自己来决定什么时候退出.**

如果是直接写死的话,让我收到命令就必须退出,假如我在跟老板汇报工作,此时女朋友让我去买菜,如果我把老板电话挂掉,那自己也就寄了.

只有自己才有资格决定自己要做什么事情,别人的话之能当作意见,只有自己是为自己好.

## 等待一个线程 ##

线程是一个随机调度过程，等待线程，就是控制两个线程的结束顺序.

但是呢?我们可以通过过`join()`方法来控制线程的执行顺序.

大家看下面的代码以及执行结果:

![在这里插入图片描述][6f0f1febd6c545769295e31422fd4477.png]  
由于线程是抢占式执行的,所以可能这次是先打印 main 但是下次可能就先打印t了,可是程序员不喜欢这种不确定性,所以我们可以通过`join()`方法来控制顺序.

大家看下面的代码和执行结果:

![在这里插入图片描述][b2afcdb30b664fda94e656f1b77ec840.png]  
当我们在 main 线程中调用 `t.join()` ,此时只有当 **t** 线程执行完之后,才会去执行 main 线程中的内容,我们也可以理解为,在哪个线程中调用`join()`方法,那么就哪个线程阻塞,只有当调用这个方法的引用所对应的线程执行完之后,才可以继续执行后续代码~

![在这里插入图片描述][4a57ee35881f4b5d996893259145b7e4.png]  
当然,这个`join()`也是可以传参数的,假如 t 线程一直没有执行完,那么我这个线程就不工作了? 就像我约女神见面一样,我等了一天,两天,三天都没等到,难道我还要等一辈子? 所以此时我们就可以传一个参数,作为最大等待时间,超过这个时间我就不等了,世界上美女那么多,我换个人舔还不行?

join方法自身也会阻塞，Java线程但凡是阻塞的方法都可能抛出这个异常(`throws InterruptedException`)。

join有两种行为：

（1）如果被等待的线程还没有执行结束，那么直接阻塞等待；

> 例如:我接我孩子放学,他5.00放学,我4.50到了,此时我就需要等待他放学,菜才能回家.

（2）如果被等待的线程已经执行结束了，就直接返回。

> 例如:我接我孩子放学,他5.00放学,我5.10才到,那么我就不用等,可以直接接回家.

join方法不带参数的时候，就是死等，一直等待下去。方法带参数的时候，如果超过了等待的最大时间，就开始执行下一步的代码。一般写带参数的join方法。

[051fef385ec344b6a2f00bd74429b59f.png]: https://img-blog.csdnimg.cn/051fef385ec344b6a2f00bd74429b59f.png
[Link 1]: https://blog.csdn.net/xiaoyubuhuiqiche/article/details/129641514?spm=1001.2014.3001.5501
[acfbd778ae144c91a305560612a995c0.png]: https://img-blog.csdnimg.cn/acfbd778ae144c91a305560612a995c0.png
[64ccb579eb7e46e984c267e9695068d7.png]: https://img-blog.csdnimg.cn/64ccb579eb7e46e984c267e9695068d7.png
[5a72a52913ba4117af1d0df9bbf64c54.png]: https://img-blog.csdnimg.cn/5a72a52913ba4117af1d0df9bbf64c54.png
[9bc16898e0b14895b5262fcf3373d253.png]: https://img-blog.csdnimg.cn/9bc16898e0b14895b5262fcf3373d253.png
[6f18ff4425d44c65ad8b7f339e6e599b.png]: https://img-blog.csdnimg.cn/6f18ff4425d44c65ad8b7f339e6e599b.png
[69703eb0eee243d28a617db1b30b791a.png]: https://img-blog.csdnimg.cn/69703eb0eee243d28a617db1b30b791a.png
[b236c29cfc344954ad9d4347842e1879.png]: https://img-blog.csdnimg.cn/b236c29cfc344954ad9d4347842e1879.png
[35f5ac83fa6145fba6e629da6441abcd.png]: https://img-blog.csdnimg.cn/35f5ac83fa6145fba6e629da6441abcd.png
[6f0f1febd6c545769295e31422fd4477.png]: https://img-blog.csdnimg.cn/6f0f1febd6c545769295e31422fd4477.png
[b2afcdb30b664fda94e656f1b77ec840.png]: https://img-blog.csdnimg.cn/b2afcdb30b664fda94e656f1b77ec840.png
[4a57ee35881f4b5d996893259145b7e4.png]: https://img-blog.csdnimg.cn/4a57ee35881f4b5d996893259145b7e4.png