JavaWeb 基础知识（二）——线程01

ゝ一世哀愁。 2022-09-16 04:50 156阅读 0赞

### 文章目录 ###

*  JavaWeb 基础知识（二）多线程01
 *  一、认识线程
 *   *  0.线程的引入
     *  1.线程的概念
     *  2.进程与线程
     *  例子
 *  二、Java中的线程
 *  1.线程的创建
 *   *  （1）run 和 start
     *  （2）创建线程的几种方式
     *  （3）jconsole 查看线程信息
     *  （4）多线程的优势-增加运行速度
 *  2.Thread 的常见构造方法
 *  3.Thread 的几个常见属性
 *   *  ID
     *  名称
     *  状态
     *  优先级
     *  后台线程
     *  存活
 *  未完待续...

# JavaWeb 基础知识（二）多线程01 #

**上节回顾**

我们在介绍本节内容之前，先来简单复习一下上一节进程的相关内容

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16]

# 一、认识线程 #

## 0.线程的引入 ##

引进进程的目的，就是为了能够"并发编程"

虽然多进程已经能够解决并发的问题了，但是我们认为，还不够理想。

创建进程、销毁进程、调度进程开销有点大了

> 进程时系统资源分配的基本单位

> 创建进程，就需要分配资源  
> 销毁进程，就需要释放资源

于是程序员就发明了一个 “线程”（Thread）的概念，线程在有些系统上也被叫做"轻量级进程".

> 轻量：  
> 创建线程比创建进程更高效  
> 创建线程比销毁线程更高效  
> 调度线程比调度进程更高效

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 1]

## 1.线程的概念 ##

> 一个线程就是一个 “执行流”. 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 “同时” 执行着多份代码.

我们站在系统内核的角度，再来看进程和线程

> 一个系统之中可能有很多个PCB（进程控制块），各个PCB通过链表进行连接，如图代表系统中已有的4个进程 （ pid 分别代表着进程id ）![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 2]

在Linux系统中，线程同样是使用PCB来描述的

> 进程1，对应一个PCB，在这个进程1里创建一个线程，也是再加了一个PCB  
> ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
>   这就是当前我们看到的一个情况，那其实，站在操作系统内核的角度，不分“**线程**”还是“**进程**”，系统只认PCB

>   我们用户在创建一个进程出来，系统内核方面就会有一个PCB插入到双向链表里面，如果我们在代码中再去创建一个新的线程，也就是再加一个PCB

>   像上面的 进程2、进程3、进程4，他们看起来没有创建其他线程，但是进程创建之初，也会有一个PCB产生，我们可以把PCB视作里面的一个线程

我们可以得到一个结论：

>   当我们创建了一个进程的时候，就是创建了一个PCB 出来，同时这个PCB也可以是当做是目前进程已经包含了一个线程了，所以一个进程中至少有一个线程。

同一个进程的线程之间，是可以共用一份内存空间的，同时其他的进程（PCB）使用的是独立的内存

>   也就是说上面的进程中，进程1和线程1 共用一份内存空间，进程2、进程3、进程4都有自己独立的内存空间。

这就是我们站在系统内核的角度描述线程基本的情况

那我们又拐回来了，线程和代码有啥关系呢？

可以认为，一个线程就是代码中的一个执行流

> 执行流：按照一定的顺序来执行一组指令

## 2.进程与线程 ##

进程与线程之间本来就是容易搞混淆的，尤其是对于Linux系统来说，进程和线程之间又是存在着千丝万缕的联系，总之呢，我们得知道 进程和线程之间 的区别和联系

**经典面试题**

**进程和线程之间的区别和联系\[面试题\]**

> 1、进程是包含线程的。一个进程里可以有一个线程，同时也可以有多个线程。

> 2、每个进程都有独立的内存空间（虚拟地址空间），同一个进程的多个线程之间，共用一个虚拟地址空间。

> 3、进程是操作系统分配资源的基本单位，线程是操作系统调度执行的基本单位

>   上节课所介绍的"进程调度"，当时咱们是没有考虑线程的，实际上系统是以线程（PCB）为单位进行调度执行的.

咱们来画图说明：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 4]  
3个进程4个线程

我们先让CPU处理 第一个PCB块，执行一段时间之后，把PCB1 释放，再来执行PCB2，执行一段时间后，再进行释放，所以系统是根据PCB进行调度执行的.

以上就是我们所讲的 线程和进程之间的区别与联系，上面的三点大家一定要有印象，是后面在面试的时候经常问到的问题。

## 例子 ##

刚才我们都一直在干巴巴的讲理论，可能是有点抽象了，那我们就再举一个例子进行说明一下吧（很形象）

> 主角：滑稽老铁  
> 道具：封闭的房间与桌上的100只鸡

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 5]

> 现在呢，房间里的桌上有100只鸡，如何提高滑稽老铁吃鸡的速度？

那么此时，我们就有两种方案：

> 1、多进程

那么多进程是怎么吃呢？

> 多进程吃鸡  
> ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 6]  
> 现在有两个房间，两套桌子，把鸡平均分成两份，两个滑稽老铁同时再房间各自吃50只鸡

这种分配的方法相比较于之前明显吃鸡的速度要高效好多。

这就是我们所说的并发编程的效率，能够提升整体程序的效率

> 两个房间、两套桌子，说明每次再创建进程，都要给这个进程分配一些资源

> 这两个房间里的滑稽老铁，相互之间都看不见彼此，说明进程之间有独立的地址空间（进程的隔离性）

这就是我们所说的多进程的吃鸡版本！

当然了，两个房间、两套桌子总体来说成本还是有点高的，所以我们为了降低成本，那么我们还可以多线程吃鸡~

> 2、多线程

多线程吃鸡怎么吃？我们这样做~

> 还是一个房间，只不过多了一个滑稽老铁来一块吃鸡![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 7]  
> 多了一个滑稽老铁（多了一个吃鸡的执行流）

每个滑稽吃50只鸡就行了 ~ 1个人吃50只肯定比1个人吃100只速度更快一些

这里还有一个很重要的问题：

>   这两个滑稽老铁共用了同一个房间和桌子,一个进程的多个线程之间，共用一个虚拟地址空间.同时，这两个滑稽老铁是可以看到对方的情况的

> 只创建了一个滑稽，桌子和房间都没有新创建，创建这个线程的成本比创建进程的成本要更低.

这就是多线程吃鸡的一个情况，那么接下来呢？

我们多线程吃鸡吃着吃着觉得效率还不够高，还可以进一步怎么提高效率呢？

> 进一步提高效率：再多搞几个滑稽（线程）![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 8]

滑稽的数目（线程的数目）更多了，每个滑稽的任务就更少了，因此整体的效率就更高了~~

就是说随着我们线程数目的增多，线程去完成同一个任务，我们的速度就会更快

但是大家注意,这里的速度也不是说线程的数目越多越好！！如果线程的数目太多了，线程之间就会更加频繁的进行调度，调度的开销也就无法忽略了！！

> 就会出现下面的情况  
> ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 9]  
> 我们增加了滑稽（线程）的数目，就可能出现有的滑稽抢不上位置（CPU）,于是任务的执行速度反而会变慢，这什么意思呢？

没有抢着位置的三个老铁，为了吃鸡，要往里面挤，于是已经围着桌子吃起来的滑稽老铁们就没有办法消停的吃鸡了，有的滑稽就可能本来吃的好好的，没一会被挤出来了，这样就会出现很多问题~

所以线程也不是越多越好，线程的数目越多，就会引发更多的调度开销，反而可能让执行任务速度变得更慢~所以这一点呢，大家也要明确.

还有一种情况，当我们很多滑稽老铁一起吃鸡的时候，可能有打架的行为~~

什么叫打架的情况呢？

> 还是刚才的饭局  
> ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_19_color_FFFFFF_t_70_g_se_x_16]  
> 两个滑稽（线程）同时看上一个鸡大腿（准备修改同一块内存的数据），这个时候就会起冲突.

这种情况，我们称为"线程不安全"，这同样也是多线程编程的重点问题，在后面的章节会着重介绍！！

> 还有一种情况，如果某个滑稽老铁不开心，某个滑稽（线程）一直抢不到桌子的位置  
> ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 10]  
> 于是这个老铁一生气，把桌子给掀了！！

这说明什么呢？

> 一个进程里面如果某个线程抛出了异常，并且没有合理catch住的话，就可能导致整个进程都异常退出.其他线程也就玩完了

所以一个线程不工作，其他的线程也全都不工作了，这一点，就对我们的多线程程序的安全性提了更高的呃要求

多线程程序的编写，其实就提出了一个更高的要求，一定要保证线程的稳定

> 讲到这呢，那么我们滑稽的案例就告一段落了~  
> 希望通过这样的一个例子，让大家更好的了解进程与线程之间的关联关系

以上就是我们所介绍的进程与线程的关联与特点，准确的来说是线程的一些特点，这些特点我们在以后写代码的时候也就会逐步的感受到了~好了，说了那么多，都是理论的知识，理论的知识大家有一个简单的认识就可以了，重点我们还是要落在代码上！！

那么接下来，我们就介绍 使用Java来操作线程Thread类（创建线程）的相关方法

# 二、Java中的线程 #

在Java当中，是使用Thread这个类的对象来表示一个操作系统中的线程

> PCB是在操作系统内核中，描述线程的  
> 而Thread类则是在Java的代码中 描述线程的.

接下来，我们就来写一下简单的代码来创建线程出来~

# 1.线程的创建 #

首先我们得去创建Thread 的实例出来，但是常见的方式并不是直接new一个对象出来.

Thread 是Java标准库中描述的一个关于线程的类.

常见的方式就是自己定义一个类继承Thread，然后重写Thread中的 run 方法，run 方法就表示线程要执行的具体任务（代码）

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 11]

> start 方法，会在操作系统中真的创建一个线程出来（同时在内核中会创建PCB，加入到双向链表当中）

执行一下

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

> 这个新的线程，就会执行 run中所描述的代码

看完这个线程的创建过程，有的同学不禁会问了，

我们在 执行代码的时候 不用 t.start ，直接执行 t.run 行不行？咱们刚才不是把代码的逻辑定义到run方法里面了嘛，那我们直接调用t.run 不是一样会执行代码嘛？？

执行一下

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 12]

那么run 和 start 方法有什么区别呢？

## （1）run 和 start ##

> 重点：经典面试题

run 和 start 的区别是非常非常大的，我们来给大家具体演示一下这个情况.

> **start 方法**

> 当我们运行Java代码的时候，首先系统会创建一个进程，这个进程里面已经包含了一个线程了，这个线程执行的代码默认就是 main 方法 ,main方法调用t.start方法，在系统中又会创建一个线程（PCB）出来,然后这个PCB执行任务代码.

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 13]

> **run 方法**

run 方法没有创建新的PCB，没有创建新的线程.

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 14]

> t.run 这里并没有创建出一个新的线程，

> 而使用t.start 这个方法可以创建出新的线程，同时t.start 的两个线程之间是属于同一进程，属于并发的关系

**例子**

如果大家还是没有懂的话，给大家再举一个例子：

> 比如说老王想买一瓶酱油，start 方法就是 老王把儿子小王叫来说，你去楼下超市去买一瓶酱油，run方法就是 老王自己去买一瓶酱油。

> 这两种方式的区别,尤其是start，就是在派小王去买酱油的同时，老王自己同时想干嘛就干嘛，这就是并发的效果.而run方法只能老王只能去买酱油了，没法干其他别的事

这样的一个区别大家一定要区分请

让大家看一下程序并发的效果

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 15]

在上面的代码中，Mythread 中执行的是一个死循环，他会一直循环执行，在主线程Main里也会一直执行循环，那么都是死循环，这两个代码能同时执行吗？

按照上面的讲解，MyThread 是一个执行流，Main 也是一个执行流，他们属于并发的关系，所以可以同时执行！

那么运行程序，观察结果~

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 16]  
  “hello main” 和 “hello thread” 进行交替打印，进一步验证了两个线程并发执行的效果。

通过刚才这个代码，我们就可以看到，我们通过线程可以让两个死循环按照并发执行的方式，一起来执行，而不是单纯的说，一个执行完才去执行另外一个。好了，这是我们通过 start 创建线程来这样做的，如果我们改成 run呢？

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 17]  
执行代码，观察结果

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 18]

就会在MyThread 的死循环中转不出去，main的循环无法执行

这里我们也可以看到 start 和 run之间很本质的区别，run 并没有创建出新的线程，它属于一个线程里面串行执行，而通过start 就可以创建新的线程，可以是两个线程以并发的方式同时来执行.

以上就是关于线程最基本的代码~

## （2）创建线程的几种方式 ##

在上面的程序中，我们是通过新建一个类继承标准库中的Thread类来创建线程的，实际上，线程的创建是有很多种方式的，下面我们就来了解一下 Java当中创建线程的几种方式.

> 1.继承Thread，重写run

我们自己建一个类继承Thread ，在这个类中重写run方法.

\*\*加粗样式\*\*

class Mythread1 extends Thread{
        
            @Override
            public void run() {
        
                // 执行的任务
            }
        }

> **2.实现Runable接口，重写 run**

> Runable 是标准库提供的一个接口，这个接口主要用于描述"一个任务"，里面也是有一个核心的run方法，通过run方法来描述具体要执行的任务代码是什么…  
> ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 19]

class MyRunable implements Runnable{
        
        @Override
        public void run() {
        
            //执行的任务
            while(true){
        
                System.out.println("hello world");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }
    
    public class Thread1 {
        
    
        public static void main(String[] args) {
        
               Thread t1 = new Thread(new MyRunable());
               t1.start();
        }
    }

**注意:**   我们的Runable 并不是能够独立去使用，还要搭配我们的 Thread 类来进行使用，new MyRunable 的实例作为 Thread 的参数,这就是当前这种方式的写法.

> 本质上和刚才继承Thread重写Run的效果一样，都是具体告诉线程具体要执行的任务是什么…

> 只不过MyRunable只是用来描述一个具体的任务是什么，而真正线程的主体还是在于我们的Thread类本身.

同时这种方式，还可以给当前创建的线程赋予名字，名字作为Thread 的第二个参数

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

> **3.继承Thread，重写run(匿名内部类)**

> 内部类：在一个类里面定义类

> 所以匿名内部类就是一个没有类名的内部类,没有类名也没有关系，至少可以创建出一个实例来~

> 那么我们什么时候需要用到匿名内部类呢？  
> 只需要这个实例，不需要用到其他实例了，  
> 匿名内部类的方式写起来更加简洁一些

那么下面我们具体来看具体的代码应该怎么写…

public static void main(String[] args) {
        
          Thread t = new Thread(){
        
              @Override
              public void run() {
        
                  // 执行任务代码
              }
          };
        }

创建了一个匿名的类，这个类继承了 Thread，此处new 的实例其实是Thread类的子类的实例

> **4.实现Runnable 重写run，使用匿名内部类**

因为都是用的匿名内部类，所以这两种写法都很像，但是我们仔细观察会发现，写法不太相同.

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 20]

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 21]  
我们把两组代码拿过来对比一下，可以看出区别来

> 第一种：我们创建匿名内部类是Thread 的子类，所以 \{\} 跟在 Thread 的后面

> 第二种：我们创建的是一个Runnable 这样的子类，new的 Runnable 子类作为 Thread 的一个参数。相当于创建了一个匿名内部类的实例，把这个实例作为 Thread的参数。

这两种写法还是有一定区别的.

以上的这些创建线程的方式，本质上都相同

>   只不过区别是，指定线程要执行的任务的方式不一样，此处的区别，其实都是单纯的Java语法层面的区别~ 所以这样的区别并不是很关键，这样的写法大家只需要多写两次去熟练就会了…

好了，写到这里，可能有同学说了

> 我们已经了解了创建线程的几种方式了，也知道如何并发执行了，那么有没有像任务管理器一样的东西让我们能够看到 Java创建的线程呢？

## （3）jconsole 查看线程信息 ##

在 JDK 中内置了一个 jconsole 工具，就可以看到线程的信息.

我们先在Java运行一个线程

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 22]

点击运行，看一看jconsole 里面的线程信息

> jconsole 在哪里找呢？  
> 先找到我们的jdk文件，bin目录下就有 jconsole.exe

打开jconsole 之后出现这样的界面

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 23]

选择本地进程Main，然后点击连接

> 注意在这里，显示的进程只是Java相关的进程，非Java的进程显示不出来

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 24]

这些线程都是当前进程的线程，对于一个Java程序来说，启动的时候不仅启动了main这样一个线程(main这个线程是 main方法对应的线程, thread-0 这个就是我们自己创建的新的线程),还有很多其他的线程，这些线程都是JVM在运行的时候内置的一些线程…

> 我们可以通过 这个工具查看每个线程的具体情况  
> ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 25]  
> 如果写的程序，发现程序挂了，就可以通过 jconsole 来查看程序里面每个线程的情况，对于分析解决问题就有很大帮助了

以上就是用 jconsole 来查看 线程相关信息的具体操作，当然了我们还可以根据其他的信息来查看，我们就暂时不去介绍这么多了~

好了，我们继续线程的另一块知识~

## （4）多线程的优势-增加运行速度 ##

之前我们介绍并发编程能够提高程序的效率，我们呢就通过 Java 的代码来了解一下 并发编程的效率

这个代码我们要干什么呢？

首先我们有一个很大的数字，这个数字是10亿

> 首先是串行执行代码，a、b分别自增10亿次

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 26]  
我们来看一下执行结果：  
![在这里插入图片描述][b33369651c4c4422b6a6e66d04b0c11d.png]

> 然后是并发执行,让a、b分别在两个线程中并发执行自增操作，然后计时.

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 27]

运行查看结果：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 28]

当前呢，使用并发的方式 确实比 串行的方式时间上 效率提高很多，

> 串行执行 600—700 ms  
> 并发执行 300—400 ms  
> 速度确实提高了好多

> 速度提高正好是提高一倍嘛？  
> 不是~（不一定）  
> 主要是因为线程调度自身也是有开销的~

> 串行执行： 一个线程执行了20亿次循环，中间可能调度若干次

> 并发执行：两个线程各自执行10亿次循环，中间可能调度若干次.

因为系统有调度，所以会对程序的运行时间有影响

# 2.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>

具体代码使用：

Thread t1 = new Thread();
    Thread t2 = new Thread(new MyRunnable());
    Thread t3 = new Thread("这是我的名字");
    Thread t4 = new Thread(new MyRunnable(), "这是我的名字");

# 3.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>

## ID ##

> ID 是线程的唯一标识，不同线程不会重复

## 名称 ##

> 名称是各种调试工具会用到

## 状态 ##

> 状态表示线程当前所处的一个情况，和上一节说的"进程的状态"是类似的效果，存在的意义都是辅助进行线程调度

## 优先级 ##

> 优先级高的线程理论上来说更容易被调度到，和上节课"进程的优先级"是类似的效果

此处的状态和优先级 ，和PCB中的状态优先级并不完全一致，Java线程在这个基础上有做了自己的丰富.

## 后台线程 ##

> 关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行。

> 我们在Java中创建的线程一般默认都是非后台线程，此时，如果main方法结束了，线程还没结束,JVM不会结束

> 如果当前线程是后台线程，此时如果main方法结束了，线程还没结束，那么JVM进程会直接结束，同时也把这个后台线程给带走了.

## 存活 ##

> 是否存活，即简单的理解，为 run 方法是否运行结束了  
> ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 29]  
> 存活是什么意思呢》我们来画一下

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 30]

> t中的代码执行完之后，Java中的线程PCB也会同时销毁吗？并不会.

> Java 中PCB对象在JVM 垃圾回收机制下才会被销毁，而操作系统内核的 PCB 在代码执行完之后就销毁了

> 所以我们就可以通过 isAlive（） 判断内核中的PCB是否存在

我们对当前程序中的线程查看属性

class MyRunable implements Runnable{
        
        @Override
        public void run() {
        
            //执行的任务
            while (true){
        
                System.out.println("hello wolrd");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }
    public class Thread1 {
        
        public static void main(String[] args) {
        
               Thread t1 = new Thread(new MyRunable(),"线程01");
               t1.run();
            System.out.println("id: "+t1.getId());
            System.out.println("name: "+t1.getName());
            System.out.println("Priority: " +t1.getPriority());
            System.out.println("State: "+t1.getState());
            System.out.println("isAlive: "+t1.isAlive());
            System.out.println("isDeamon: "+t1.isDaemon());
        }
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 31]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 32]

好了，今天的线程就讲到这里，希望大家多多复习~

谢谢欣赏！！

下一篇 JavaWeb基础知识（三）——线程02 敬请期待~

# 未完待续… #

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/f9a0d424ad454f90909056dcdfe0b984.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/9a52d09a52564f8c8335039030dfe3a9.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/cb78e012e22a4dabbf8bcc916332e4d2.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220828/8e4d971a1b3341d5966aea48c9b057d3.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220828/fe579a81af1d4a5bae87d6cd74c697ea.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220828/774e058fa0234d1a8138171377bda763.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20220828/3d93603f322e46d6b05cf48d5a25aa5d.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 7]: /images/20220828/82c310fbb02b4427b15a2bf6d534965f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 8]: /images/20220828/adb0c0ece20f44609964e6b042eda685.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 9]: /images/20220828/7efb80abe4854716acc75788ca5164c7.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_19_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/1955eb0fc5684f81b68fa4e2eb2fd151.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 10]: /images/20220828/c6a1191e481042b290642b6028c6e9ee.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 11]: /images/20220828/bc81dad53e3c44089d9ce37837d733ad.png
[4cd17be04d264a31b4359868bee8b9a7.png]: /images/20220828/9579544f68184daea726258d52640e06.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 12]: /images/20220828/8963e3cd0a8240afae746dc877d165a2.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 13]: /images/20220828/14f0b3950f5042a29b3fe13923d33e07.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 14]: /images/20220828/13e19f80530b494d9336fac52483c5fc.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 15]: /images/20220828/c29d40ade5b64c34974814807c793d71.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 16]: /images/20220828/0be7a945e139447e996d91456f33571f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 17]: /images/20220828/00dbe6f2f7ee4051bbaeb58b80d1fe8c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 18]: /images/20220828/c98eecfca3ee4e3eb458d69e50c60376.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 19]: /images/20220828/234e5da9d58a484e973f644ea7fbe049.png
[bb655b6b2426454d9452ab5f7a1aec4b.png]: /images/20220828/badda0fb6c114cdb8b94cccfb2e4b189.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 20]: /images/20220828/292308ad76d94799adbe9b30e5b3e8e3.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 21]: /images/20220828/886f253b4666494f8075308824719e9d.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 22]: /images/20220828/112ac73bf1b54e10b40f2f3fcd661fc5.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 23]: /images/20220828/1c1609469d1449219f72cb1f1424f21d.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 24]: /images/20220828/5b8f58195fed41de9971bb86c2c6e641.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 25]: /images/20220828/596d76f2631e4ab1a9475e75fe047e24.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 26]: /images/20220828/1e40bf81b3f140d69881bb3758432713.png
[b33369651c4c4422b6a6e66d04b0c11d.png]: /images/20220828/c27326b725d8403a86ec7842d11f44fe.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 27]: /images/20220828/b9b93352533c491d8c55cf2fed17b05c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 28]: /images/20220828/89e156cc93d346d08329e61cdd1dde55.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 29]: /images/20220828/5cb6bb10b490418e88719b59c299b0a8.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 30]: /images/20220828/c3b6d5b83133480bab1a2dd3e0413387.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 31]: /images/20220828/ed44e0ea51da4415bd4f4e01f5780987.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAUkFJTiA3_size_20_color_FFFFFF_t_70_g_se_x_16 32]: /images/20220828/16f9b008ad284accaef5fd0ad4530bd6.png