【JavaEE】认识线程&Thread类及常用方法&线程状态

╰+攻爆jí腚メ 2024-03-30 17:46 13阅读 0赞

**目录**

一：认识线程：

二、线程的优点：

三、进程和线程的区别（面试题）：

四、第一个多线程程序：

五、创建线程的方式：

六、Thread类及常用方法

Thread类常见构造方法：

Thread(String name)

Thread（Runnable target，String name）

Thread常见属性：

ID&名称：

状态：

优先级

后台线程

存活

中断

--------------------

## 一：认识线程： ##

每一个线程就是一个“执行流”。每个线程之间都可以按照顺序执行自己的代码，多个线程之间可以同时执行自己的代码。比如我们之前一直写的程序都只是在main线程中写的代码，以前写的代码都是单个线程的。

那么为什么会出现线程？主要有2个原因：

1）并发编程的需要

单核CPU的发展已经到了瓶颈，现在已经到了多核CPU的时代，而并发编程可以让CPU的资源得到充分的利用。

2）进程太“重”了。

虽然进程也可以实现并发编程，但是进程还是太“重”了。

进程在创建时开销非常大

进程在销毁是开销非常大

进程在调度的时候也开销非常大！

我们这里所说的“重”指的是“资源分配/回收”。

## 二、线程的优点： ##

所以我们的线程就应运而生。相对于进程而言。线程就更加的“轻量化”了，所以线程也被称为“轻量化进程”。这里说的轻量是因为线程在创建、销毁和调度的时候的开销都要比进程低。而线程之所以开销低的原因又在于线程省去了一些“申请资源和释放资源的步骤”。

比如这样的一个例子：

小明家开了一个工厂来生产冰箱，经过了一段时间的经营，发现生产的冰箱非常的受欢迎，销量很高，于是小明想到了两种方案来提高生产力：

方案一（多进程方案）：再寻找一个工业场地，购进一批同样的机器来进行生产。

![c9c980b0164d454783acacdd9929434f.png][]

方案二（多线程方案）：把原工厂的地方拾掇拾掇，腾出一块地方，购进一批新的机器放机器进行生产

![aa7aa63f67b04b38a6a178b9914d96c1.png][] 显然我们可以看出，第二种方案（多线程）的开销要明显低于第一种方案（多进程）。因为第二种方案没有进行更大的资源开销，而是在原工厂的基础上进行了复用，也就是还是利用了原场地。这样下来的开销就大大减少了。

## 三、进程和线程的区别（面试题）： ##

**1.、进程包含线程。一个进程中可以有一个线程，也可以有多个线程。**

**2、进程和线程都可以解决并发编程问题，但是进程在频繁的创建和销毁的时候开销更大，线程更小。（线程比进程更加的轻量）**

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

**4、进程与进程之间不共享内存空间，同一个进程中的线程共享内存空间。（这就可能会出现一个线程崩了，别的也会收到影响，而进程之间不会影响。也就是说进程比线程更安全）**

## 四、第一个多线程程序： ##

线程是操作系统里面的概念，Java标准库中的Thread类可以视为是对操作系统提供的API进行了抽象和封装。

通过第一个多线程的程序感受一下多线程和单一线程的区别。

package Thread;
    
    class myThread extends Thread{
        //使用一个boolean类型进行判断，让该线程只打印100次
        private boolean flag=true;
        private int count=1;
        @Override
        public void run() {
    
            while(flag){
                if(count==100){
                    flag=false;
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("hello Thread");
                count++;
            }
    
        }
    }
    public class ThreadDemo2 {
        public static void main(String[] args) throws InterruptedException {
            Thread t=new myThread();
            t.start();
            //主线程打印50次
            for (int i = 0; i <50 ; i++) {
                Thread.sleep(500);
                System.out.println("hello main");
            }
    
    
        }
    }

![fccb8958f1874b2c9fc0a75edd7ba63f.png][]

该程序并没有先执行其中一个线程，在执行另一个的线程，这就是多线程的魅力所在。

我们从上述结果中也可以看到一个现象就是main线程和t线程谁先执行是不确定的，是完全由我们的系统自己决定的。所以线程的调度是**“抢占式执行，随机调度”**。

## 五、创建线程的方式： ##

我们创建线程可以有五种方式：

1、创建子类继承Thread类，重写run方法。

package Thread;
    
    class myThread1 extends Thread{
        @Override
        public void run() {
            System.out.println("hello Thread");
        }
    }
    public class ThreadDemo3 {
        public static void main(String[] args) {
            Thread t1=new myThread1();
            t1.start();
        }
    }

![31400b1a8a40418f81a1abe2eb66f674.png][]

run方法描述了该线程要执行的任务内容，即要执行的代码，而调用start方法才是真正创建了线程，才会执行任务。

2、实现Runnable接口，重写run方法。

package Thread;
    
    class myRunnable implements Runnable{
    
        @Override
        public void run() {
            System.out.println("hello Thread");
        }
    }
    public class ThreadDemo4 {
        public static void main(String[] args) {
            myRunnable runnable=new myRunnable();
            Thread t=new Thread(runnable);
            t.start();
    
        }
    }

![5fc38df9ff474fb29353a050324c70cf.png][]

这个方法是通过实现Runnable接口，创建出一个Runnable的实例，把这个实例传给Thread对象，通过这个实例来描述要执行的任务。

3、匿名内部类创建Thread子类对象。

package Thread;
    
    public class ThreadDemo5 {
        public static void main(String[] args) {
            Thread t=new Thread(){
                @Override
                public void run() {
                    System.out.println("hello Thread");
                }
            };
    
            t.start();
    
        }
    }

![ed946baa73f74881a9616518d6a3f88c.png][]

4、匿名内部类创建Runnable子类对象

package Thread;
    
    public class ThreadDemo6 {
        public static void main(String[] args) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello Thread");
                }
            });
            t.start();
        }
    }

![f8b111f88b0f40f190e9d20f022ff0e4.png][]

5、**使用lambda表达式（最推荐写法）**

package Thread;
    
    public class ThreadDemo7 {
        public static void main(String[] args) {
            Thread t=new Thread(()->{
                System.out.println("hello Thread");
            });
            t.start();
        }
    }

![176b677e0de84228a055330b8679b3a5.png][]

## 六、Thread类及常用方法 ##

### Thread类常见构造方法： ###

![b4602a603544488b8d4479305384fe98.png][]

#### **Thread(String name)** ####

这个方法就是在我们创建线程的时候，对线程进行命名。我们上面的t线程这样的说法注意这里的t是指Thread对象，不是我们线程的名字。所以我们可以通过这个方法对线程进行命名，避免线程混乱的情况。

package Thread;
    
    public class ThreadDemo8 {
        public static void main(String[] args) {
            Thread t=new Thread(()->{
                while (true) {
                    System.out.println("hello Thread10086");
                }
            },"Thread10086");
            
            t.start();
        }
    }

然后我们运行后可以通过java的jdk自带的工具程序来进行线程的管理和监视。这就用到了我们的jconsole工具。

![2687b83e6df64211b616c746aa6de5a5.png][]

![d3c3037767034e34bf363319b88d0073.png][] ![fbfcf839e227432bb1c37763179fc8e8.png][]然后就是介绍一下**Thread（Runnable target，String name）**

#### **Thread（Runnable target，String name）** ####

这个就是上述的使用Runnable对象来创建线程的方法了。

package Thread;
    
    public class ThreadDemo9 {
        public static void main(String[] args) {
            Thread t=new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true){
                        System.out.println("hello Thread10010");
                    }
    
                }
            },"Thread10010");
            t.start();
        }
    }

然后我们通过jconsole观察一下：

![c624d6cdf6d5422da4ece6ec6933262f.png][]

然后下面是Thread的几个常用的属性。

### Thread常见属性： ###

<table> 
 <tbody> 
  <tr> 
   <td>属性</td> 
   <td>获取方法</td> 
  </tr> 
  <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是每个线程独一无二的身份标识。

名称是每个线程的名字。

package Thread;
    
    public class ThreadDemo10 {
        public static void main(String[] args) {
            Thread t1=new Thread(()->{
    
            },"T1");
            Thread t2=new Thread(()->{
    
            },"T2");
    
            t1.start();
            t2.start();
            System.out.println(t1.getId());
            System.out.println(t2.getId());
            System.out.println(t1.getName());
            System.out.println(t2.getName());
        }
    }

#### ![cb3e01b27cc54876aafeec74746852b1.png][] ####

#### 状态： ####

状态是当前线程所处的状态。

线程的状态有以下几种：

1、NEW 安排了工作，还没有开始行动

2、RUNNABLE 可工作的（包括正在工作和即将开始工作）

3 、TERMINATED 工作完成了

4、BLOCKED 排队等待其他事情

5、WAITING 排队等待其他事情

6、TIMED\_WAITING 排队等待其他事情

**NEW**

首先说一下NEW，这个就是在我们的run方法中没有进行任务的执行。

package Thread;
    
    public class ThreadDemo11 {
        public static void main(String[] args) {
            Thread t=new Thread(()->{
                System.out.println("hello");
            });
           // t.start();
            System.out.println(t.getState());
        }
    }

![79235b0f03f34ede9ab69490a05ebb3d.png][]

我们没有进行线程的启动，就说明了我们只是描述了任务是什么（打印hello），但是没有去执行这个任务，所以状态就是NEW

**RUNNABLE**

那么我们如果的任务没有进行描述，但是我们启动了线程，就相当于老板没有给员工下达任务，员工此时就是可以执行任务的状态RUNNABLE（就是闲着）。

package Thread;
    
    public class ThreadDemo12 {
        public static void main(String[] args) {
            Thread t=new Thread(()->{
    
            });
            t.start();
            System.out.println(t.getState());
        }
    }

![29bb01cca4444d7ca7789e9f5ee88188.png][]

**TERMINATED**

这个就是表示线程执行完毕了。我们可以用以下代码做理解。

package Thread;
    
    public class ThreadDemo12 {
        public static void main(String[] args)   {
            Thread t=new Thread(()->{
    
            });
            t.start();
            //使用一个sleep使得t线程先执行完毕
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(t.getState());
    
            }
    }

![a99a5941cc2445e0a23681878748bc5a.png][]

**BLOCKED**

BLOCKED这个状态常见于加锁状态，当我们对其进行加锁（synchronized）之后 ，别的对象来获取锁的时候就需要阻塞等待，直到加锁的对象释放锁之后，才有机会获取到锁。

目前先知道对一个代码块加锁后就会出现所谓的加锁状态即可，后面会告诉大家为什么我们要进行加锁操作。

![f84364344c1b4e5aa0573c97b9576db1.png][]

**WAITING**

WAITING表示排队等待其他事情。（这里先不展开，后面会介绍）

**TIMED\_WAITING**

TIMED\_WAITING也表示排队等待其他事情，但是这里的排队是由于系统调用了sleep方法而进入的状态。表示了当前线程需要阻塞等待一定的时间。

package Thread;
    
    public class ThreadDemo14 {
        public static void main(String[] args) {
            Thread t=new Thread(()->{
                while (true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                
            });
            t.start();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(t.getState());
        }
    }

![62fea635347f478da03b2946adc34a93.png][]

附赠**状态一览表（简略示意）**：

![e9434c2c358c4561a029d5bf62fa0021.png][]

#### 优先级 ####

优先级高的线程理论上来说更容易被调度到

#### 后台线程 ####

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

#### 存活 ####

是否存活，即简单的理解，为 run 方法是否运行结束了

#### 中断 ####

有关线程中断的问题我们后面再总结，这点的篇幅可能会有点长，不便于总结在此处。

好了，今天的认识线程&Thread类及常用方法&线程状态就大概总结到这里了，下一篇准备总结一下有关线程安全的那些事。

[c9c980b0164d454783acacdd9929434f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c807e1dddadc47f0853bf0cccd81ec06.png
[aa7aa63f67b04b38a6a178b9914d96c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/68dc47addbc94473b1a75eeecc51b77f.png
[fccb8958f1874b2c9fc0a75edd7ba63f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/5d0ad4c687a043349db372bedafc854f.png
[31400b1a8a40418f81a1abe2eb66f674.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/fd1f911b66ca4e7e92d960a2553811ab.png
[5fc38df9ff474fb29353a050324c70cf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f0fa646b39b74e36a5a47b473c919833.png
[ed946baa73f74881a9616518d6a3f88c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/af4e201654484f5e8e67240ab8418ba4.png
[f8b111f88b0f40f190e9d20f022ff0e4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/470bb2c6e9bb480896f43447444358d7.png
[176b677e0de84228a055330b8679b3a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/eea8781ce0284b0c92117e60973990d1.png
[b4602a603544488b8d4479305384fe98.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/03b7ef89afef43c1874035e4bcbb8ac4.png
[2687b83e6df64211b616c746aa6de5a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7fdfc71374924a9fa6de1cf6fa9ccaa5.png
[d3c3037767034e34bf363319b88d0073.png]: https://img-blog.csdnimg.cn/d3c3037767034e34bf363319b88d0073.png
[fbfcf839e227432bb1c37763179fc8e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/29a3e4597ada47ac8b41cf42e18692c2.png
[c624d6cdf6d5422da4ece6ec6933262f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1702c9a4b8f04ff3848e30fd69ea3ab0.png
[cb3e01b27cc54876aafeec74746852b1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/85063e98782942d184a6adf293c36c91.png
[79235b0f03f34ede9ab69490a05ebb3d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1c8cadc8b7b14b788c72248498baf25e.png
[29bb01cca4444d7ca7789e9f5ee88188.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7531d41cc6cd4989a485bc5090cec2f2.png
[a99a5941cc2445e0a23681878748bc5a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4573ab1b70f841738c70e0d687950bbd.png
[f84364344c1b4e5aa0573c97b9576db1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e82bcfd24be3417bb7ccee0aaa4857d5.png
[62fea635347f478da03b2946adc34a93.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d95e129d59b54772ace32901d5f31b42.png
[e9434c2c358c4561a029d5bf62fa0021.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1d579c8c40be40658ae21c44fe8c39db.png