【Java系列】详解多线程（二）——Thread类及常见方法（上篇）

左手的ㄟ右手 2024-04-27 07:08 8阅读 0赞

> 个人主页：[兜里有颗棉花糖][Link 1]  
> 欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 [兜里有颗棉花糖][Link 1] 原创  
> 收录于专栏【[Java系列专栏][Java]】【[JaveEE学习专栏][JaveEE]】  
> 本专栏旨在分享学习Java的一点学习心得，欢迎大家在评论区交流讨论💌

#### 目录 ####

*  一、前文回顾
 *  二、创建线程的几种方式。
 *   *  继承Thread类
     *  实现runnable方法
     *  lambda表达式
 *  三、Thread类及常见方法
 *   *  Thread类的常见构造方法
     *  Thread类的属性

## 一、前文回顾 ##

我们先来回顾一下线程与进程之间的联系。

我们知道多进程可以帮助我们完成并发编程，即可以把多个cpu核心充分利用起来以完成同时执行多任务的场景。但是进程有一个问题就是进程的创建和销毁的开销是比较大的，如果我们需要频繁的创建和销毁进程的话，那么多进程这种方式就是比较低效的。所以就衍生出了轻量级进程——线程。**线程之所以比进程更轻量级主要有两方面的原因**：

*  一方面是线程共享进程的资源，**不要忘记，线程是进程的一部分，线程可以共享那些属于进程的资源，但是进程之间是相对独立的，线程创建时不需要像进程那样需要分配独立的资源，`因此线程创建和销毁的开销会比进程小很多`；**
 *  **另一方面`线程调度切换要比进程调度切换要快上很多`，由于多线程使用的调度算法比单进程要复杂很多，加上线程对系统资源的共享（线程在同一个进程内共享资源，线程切换只需要切换线程的上下文，而不需要切换整个进程的上下文；而相比之间进程切换需要保存和恢复进程的所有上下文信息，包括内存映像、打开的文件、进程状态等。），所以线程调度之间的切换要比进程调度的切换快上很多，也更容易实现多任务的处理。**

**线程在同一进程内共享内存资源，所以当进程创建完成时，线程已经可以访问和共享这些内存资源（主线程是在进程创建时默认创建的一个线程）。如果后续需要我们创建其它的线程，我们就可以重用之前的字眼就可以了。**

**进程包含了线程，一个进程内部至少有一个线程，进程是系统中分配资源的基本单位，而线程是cpu调度执行的基本单位。`我们可以这样说线程的引入最主要的就是为了实现更高效的并发处理和资源共享。`**

**由于线程可以共享同一进程内的内存资源，因此资源分配的主要任务是为进程分配足够的内存空间，对线程的资源分配比在进程级别上的资源分配要少得多。**

**`现在问题来了，一个进程内既然可以存在多个线程，同时线程可以共享同一个进程内的资源，这也意味着这多个线程之间的相互干扰会比较大（这一点就不如进程之间那样相对独立一些，一个进程挂掉知道后不会对其它进程产生影响。），一旦某个出现异常之后就有可能导致整个进程都会挂掉，这当然会对其它线程产生影响。`另外，多个线程去访问同一块公共资源的时候也可能会出现冲突带来线程安全的问题。**

**所以，总的来说使用多线程的方式完成任务比多进程的方式完成任务会有优势，但同时存在一些缺点。但尽管如此，我们依然可以利用多线程的方式来很好的完成并发编程的任务。**

**好了，友友们，回顾到此结束，接下来我们一起学习新的内容吧！！！**

## 二、创建线程的几种方式。 ##

Java标准库中，提供了`Thread()类`来表示线程，同时Java创建线程的方式有很多种。最常见的两种写法：`继承Thread()类`、`重写Runnable方法()`。

### 继承Thread类 ###

`方式一`：通过**继承thread类**来重写run方法是一种创建线程的方式（这里我们需要自己创建一个类来继承thread方法）；`方式二`：还有一种方式我们也可以创建线程：**基于匿名内部类的形式来继承thread类，并重run方法。**

> **现在我们通过匿名内部类的方式来创建线程（基于匿名内部类的形式来继承thread类，并重写run方法，即方式二）：**

**代码如下：**

public class Demo03 {
        
        public static void main(String[] args) {
        
            Thread t = new Thread() {
        
                @Override
                public void run() {
        
                    while(true) {
        
                        System.out.println("hello thread!!!");
                        try {
        
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                    }
                }
            };
            t.start();
        }
    }

> **解释：上述代码中我们创建了一个子类，这个子类（此类就是我们说的匿名内部类）继承自Thread类，同时我们在这个子类重对run方法进行了重写。**  
> **另外我们还创建了该子类（也就是之前说的匿名内部类）的实例，用引用`t`类指向这个实例。**  
> **最后就是通过引用t来调用start方法来调用系统API，再从内核中把线程创建出来。**  
> ![在这里插入图片描述][b34c8a7fc0464907aa35072f70be7ab4.png]  
> **最后我们来看一下运行结果：**  
> ![在这里插入图片描述][b80561d6038a413c8a0993e9a86f692a.png]

### 实现runnable方法 ###

`方式三`：**通过实现`runnable`来重写run方法（这里是自己创建一个类）的方式**可以创建一个线程。`方式四`：另外我们这里依然可以用其它方式来创建一个线程：即基于匿名内部类的形式来**实现runnable**并重写run方法。

> **现在我们通过匿名内部类的形式来实现runnable并重写run方法（即方式四）来创建线程，代码如下：**

public class Demo04 {
        
        public static void main(String[] args) {
        
            Thread t = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    while(true) {
        
                        System.out.println("hello world");
                        try {
        
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                    }
                }
            });
            t.start();
        }
    }

> **解释，上述代码中，我们创建了`runnable`的子类，并重写了`run方法`，然后创建出了runnable的子类的实例，把这个实例传给Thread的构造方法。**

### lambda表达式 ###

我们还可以通过lambda表达式来表示run方法的内容，从而创建出线程。

**代码如下：**

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

> **什么是lambda表达式：lambda表达式本质上就是一个匿名函数，主要可以用来作为回调函数来进行使用。**  
> **先来回顾一下回调函数吧：回调函数不需要我们自己去进行调用，因为回调函数会在特定的时机自动地被调用。**  
> **此时的回调函数就是在线程创建成功之后才会真正执行。**

**关于线程的创建这里，也有其它的方式，比如基于callable的方式创建线程，基于线程池的方式创建线程。**

## 三、Thread类及常见方法 ##

**Thread类是`JVM`用来管理线程的一个类，换句话说，每个线程都有一个唯一的Thread对象与之关联。我们对线程的各种操作都是根据Thread类进行展开的。**

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

这里我们可以参照Java官方文档：[https://docs.oracle.com/javase/8/docs/api/index.html][https_docs.oracle.com_javase_8_docs_api_index.html]  
![在这里插入图片描述][1c785911b6aa438bba4d6ec484144240.png]

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

> **如下图的代码中，我们给线程起了个名字`mythread`**  
> ![在这里插入图片描述][8f5f80f1dc8f44c0bc4f02519ebedd24.png]  
> **我们可以通过`JVM`中的`jconsole.exe`来看到这个线程（`mythread`）：**  
> ![在这里插入图片描述][c7a202a266244b90a84d56c0bde6ca47.png]  
> **现在问题来了，为什么我们没有看到主线程（main）呢**？在上述代码中，主线程创建并启动了一个新线程，而新线程负责打印`"hello thread"`的消息。由于新线程的循环中有一个线程休眠的操作（Thread.sleep(1000)），所以您将会在不同时间间隔内看到"hello thread"的输出。但这个输出是由新线程负责的，而不是主线程。  
> 所以，我们没有看到主线程的原因是主线程没有显示任何输出或执行其他代码来表明它的存在。它仅仅完成了创建和启动新线程的任务，然后退出。  
> **对于主线程来说，`main方法`就是主线程的入口；而对于其它线程来说，lambda或者run就是线程的入口。所以执行完线程的入口函数，线程就算是结束了。**

### Thread类的属性 ###

**下面是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>isDasmon()</td> 
  </tr> 
  <tr> 
   <td>是否存活</td> 
   <td>isAlive()</td> 
  </tr> 
  <tr> 
   <td>是否被中断</td> 
   <td>isInterrupted()</td> 
  </tr> 
 </tbody> 
</table>

*  **ID：这里是JVM给线程设定的身份标识。对于一个线程来说，身份标识可以有好多个，就像一个人有大名也有小名。比如JVM给某一线程设定了一个身份标识，phread库（系统给开发人员提供的操作线程的API）也有一个线程的身份标识，内核中还有一个线程的身份标识，这几个身份标识之间相互独立互不干扰。**
 *  **名称：设置线程名称方便我们知道这个线程是干什么用的，同时也方便我们去进行调试。**
 *  **状态：Java中的线程状态和操作系统中的有所区别，Java中的线程状态更加细化。**
 *  **优先级：关于获取、设置线程的优先级其实并没有太大意义，因为`系统内核进行线程调度的速度极快（线程调度是由系统内核负责的）`，快到我们根本无法感知，所有我们一般使用默认的线程优先级即可。**
 *  **是否是后台线程：后台线程又称为守护线程，后台线程不会影响线程结束；而前台线程会影响线程结束，如果前台线程没有执行完的话，进程是不会结束的；一个进程中如果所有的前台线程都执行完此时进程退出，如果此时依然存在后台线程没有执行完的话，后台线程依然会随着进程的退出而退出。`我们创建的线程默认是前台线程。`如下代码进行演示：**

// 这里我们创建的线程是前台线程
    public class Demo07 {
        
        public static void main(String[] args) {
        
            Thread t = new Thread(()->{
        
                while(true) {
        
                    System.out.println("hello thread!!!");
                }
            });
            t.start();
        }
    }
    
    // 这里将我们创建的线程设置为了后台线程
    public class Demo07 {
        
        public static void main(String[] args) {
        
            Thread t = new Thread(()->{
        
                while(true) {
        
                    System.out.println("hello thread!!!");
                }
            });
            t.setDaemon(true);
            t.start();
        }
    }

**当我们把创建的线程设置为后台线程之后，程序运行起来之后就会立即结束。原因：由于我们把自己手动的线程创建成了后台线程，所以此时就只剩下main主线程了，而main线程这里不需要执行代码，所以执行时间极短main线程（前台线程）就结束了，而我们设置的后台线程还没有来得及执行就随着进程的退出而退出了。**

*  **是否存活（`isAlive()`）：这里的存活指的并不是thread对象是否存活，而是指的thread对象（我们也可以称为线程对象）对应的线程（即系统内核中的线程）是否存活。`Thread对象的声明周期并不是和系统内核中的线程的生命周期完全一致。一般来说都是先把thread对象创建好，然后手动调用start方法，此时内核才真正创建出线程。`对于线程，当它的run方法执行完后，线程的生命周期也会自然结束，就算线程对象还存在于内存中。此时该线程会释放占用的资源并进入死亡状态；还有另外一种情况就是线程对象生命周期的结束（即没有引用指向该线程对象了），此时线程也会结束，这种情况下，线程的run方法执行与否并不影响线程的结束状态。垃圾回收器会在适当时候回收无引用的线程对象，并释放相关资源。**

**好了，本文到这里就结束了，希望友友们可以支持一下一键三连哈。嗯，就到这里吧，再见啦！！！**

![在这里插入图片描述][fac1041511584f548ec1a017c316e3df.gif]

[Link 1]: https://xiaofeizhu.blog.csdn.net/
[Java]: https://blog.csdn.net/m0_74352571/category_12520599.html
[JaveEE]: https://blog.csdn.net/m0_74352571/category_12524555.html?spm=1001.2014.3001.5482
[b34c8a7fc0464907aa35072f70be7ab4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/d2382985610c414bb39f44121de27e43.png
[b80561d6038a413c8a0993e9a86f692a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/cc286e0f4e904a1a95254d923ec87c62.png
[https_docs.oracle.com_javase_8_docs_api_index.html]: https://docs.oracle.com/javase/8/docs/api/index.html
[1c785911b6aa438bba4d6ec484144240.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/ba0424e1a33146d0b94db18007468699.png
[19042884990f4320817f047f9005c4b8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/0a8f343f2c5c4c959b20c0d4836897f4.png
[8f5f80f1dc8f44c0bc4f02519ebedd24.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/02ade2b95c454b1c9fca1cd4edc1708c.png
[c7a202a266244b90a84d56c0bde6ca47.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/0333d871224a48238ff524fef87eb105.png
[fac1041511584f548ec1a017c316e3df.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/f74e229ba19c46b08665026568f3d952.gif