Java中线程的创建与使用、Thread类的常用方法

小灰灰 2023-10-12 20:08 26阅读 0赞

# 1、什么是进程与线程 #

# 1.1 含义 #

# 1.1.1 进程 #

进程是指正在运行的程序的实例。在操作系统中，一个进程代表了一个正在执行的程序，它包括了程序的代码、数据以及程序执行时所需要的系统资源。

最直观的就是我们任务管理器：

![format_png][]

任务管理器中的每一个应用程序都是一个进程。

# 1.1.2 线程 #

线程是进程中的一个执行单元。**一个进程可以包含多个线程，每个线程都拥有独立的执行路径，可以独立执行特定的任务，一个进程中的所有线程都共享这个进程的资源。**

![format_png 1][]

比如下面的这个例子。 进程：餐厅的整个经营过程可以看作一个进程。它包括了所有的资源和活动，例如厨房、餐厅大厅、服务员、厨师、顾客等。 线程：在餐厅中，服务员可以看作是一个线程。有很多个服务员，他们分别负责接待顾客、记录订单、传递菜单、上菜等任务。服务员是餐厅进程中的一个执行单元，他与其他服务员共享同一份资源，如餐厅的桌子、厨房、食材等。多个服务员可以并行执行任务，提高效率。

# 1.1.3 线程与进程的区别 #

进程的诞生就是为了实现程序的并发执行。所谓并发，就是在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。

线程的诞生目的是为了减少程序在并发执行时所付出的时空开销，使操作系统具有更好的并发性。

*  **地址空间**：线程共享本进程的地址空间，而进程之间是独立的地址空间。
 *  **资源**：线程共享本进程的资源如内存、I/O、CPU等，而进程之间的资源是独立的。
 *  **健壮性**：多进程要比多线程健壮，一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。
 *  **执行过程**：每个独立的进程有一个程序运行的入口、顺序执行序列和程序出口，执行开销大。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，执行开销小。
 *  **可并发性**：两者均可并发执行。
 *  **切换时**：进程切换时，消耗的资源大，效率低。所以涉及到频繁的切换时，使用线程要好于进程。
 *  **其他**：进程是**操作系统资源分配**的基本单位，线程是**操作系统调度**的基本单位。

# 1.2 PCB与TCB #

进程控制块 PCB(Process Control Block)，它是**用来描述和控制进程的运行的一个数据结构**。它是进程存在的唯一标志，也是操作系统管理进程的重要依据。

TCB(Thread Control Block)是线程控制块的缩写，是**操作系统中用来描述和控制线程运行**的一种数据结构。

它们的关系：

![format_png 2][]

PCB中存储了进程的标识符、状态、优先级、寄存器、程序计数器、堆栈指针、资源清单、同步和通信机制等信息。PCB是进程存在的唯一标志，也是实现进程切换和调度的基础。

TCB与PCB是差不多的，TCB中也存储了线程的标识符、状态、优先级、寄存器、程序计数器、堆栈指针、信号屏蔽等信息。TCB是线程存在的唯一标志，也是实现线程切换和调度的基础。

# 2.创建线程的几种方式 #

线程是操作系统中的概念。操作系统内核实现了线程这样的机制，并且对用户层提供了一些 API 供用户使用。Java 标准库中 Thread 类可以视为是对操作系统提供的 API 进行了进一步的抽象和封装。

# 2.1 继承 Thread 类 #

（1）继承 Thread 来创建一个线程类。

java复制代码class MyThread extends Thread{
        //重写run方法，run 表示这个线程需要执行的任务
        @Override
        public void run() {
            System.out.println("这个线程需要执行的任务");
        }
    }

（2）创建 MyThread 实例。

java复制代码//创建一个 MyThread 实例
    MyThread myThread = new MyThread();

（3）调用 start() 方法，线程开始执行。

java复制代码//start 方法表示这个线程开始执行，注意，这里不是调用 run()方法
    myThread.start();

# 2.2 实现 Runnable 接口 #

（1）实现 Runnable 接口。

java复制代码//通过 实现 Runnable 接口来创建一个线程
    class MyRunnable implements Runnable{
    
        //需要重写run方法
        @Override
        public void run() {
            System.out.println("这个线程需要执行的任务");
        }
    }

（2）创建一个 Thread 实例。

java复制代码//创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为参数。
    Thread thread = new Thread(new MyRunnable());

（3）调用 start() 方法，线程开始执行。

java复制代码//线程开始运行
    thread.start();

# 2.3 其它变形 #

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

java复制代码Thread thread1 = new Thread(){
        @Override
        public void run() {
            System.out.println("使用匿名类创建 Thread 子类对象");
        }
    };

*  匿名内部类创建 Runnable 子类对象。

java复制代码Thread thread2 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("使用匿名类创建 Runnable 子类对象");
        }
    });

*  lambda 表达式创建 Runnable 子类对象。

java复制代码Thread thread3 = new Thread(()-> {
        System.out.println("使用匿名类创建 Thread 子类对象");
    });

# 3.Thread 类的常见方法 #

# 3.1 Thread 的常见构造方法 #

<table> 
 <tbody> 
  <tr> 
   <td> <p>方法</p> </td> 
   <td> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td> <p>Thread()</p> </td> 
   <td> <p>创建线程对象</p> </td> 
  </tr> 
  <tr> 
   <td> <p>Thread(Runnable target)</p> </td> 
   <td> <p>使用 Runnable 对象创建线程对象</p> </td> 
  </tr> 
  <tr> 
   <td> <p>Thread(String name)</p> </td> 
   <td> <p>创建线程对象，并命名</p> </td> 
  </tr> 
  <tr> 
   <td> <p>Thread(Runnable target, String name)</p> </td> 
   <td> <p>使用 Runnable 对象创建线程对象，并命名</p> </td> 
  </tr> 
 </tbody> 
</table>

java复制代码Thread thread = new Thread("小明"){
        @Override
        public void run(){
            while(true){
            	System.out.println("我是小明");
        	}   
        }
    };

这个线程的名字为“小明”，如何查看这个线程的名字呢？在Java开发工具包（JDK） 中，可以使用jconsole来监视线程。

1.  打开你的 jdk 路径，我这里是C:\\Program Files\\Java\\jdk1.8.0\_31\\bin，打开该路径下的jconsole工具。
2.  运行上面的代码，然后根据如下操作：

![format_png 3][]

![format_png 4][]

![format_png 5][]

![format_png 6][]

可以看到有一个叫“小明”的线程，这个就是我们创建的线程。

# 3.2 获取 Thread 属性的方法 #

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

*  ID 是线程的唯一标识，不同线程不会重复。
 *  名称是线程的名称。
 *  状态表示线程当前所处的一个情况，比如阻塞、运行等。
 *  优先级高的线程更容易被调度到。
 *  关于后台线程：后台线程（Daemon Thread）是在程序运行过程中在后台提供服务的线程。与前台线程（也称为用户线程）相对，后台线程不会阻止程序的终止。当**所有的前台线程（用户线程）结束时，后台线程会自动被终止**，即使它们尚未执行完毕。
 *  是否存活，即简单的理解，为 run 方法是否运行结束了。

# 3.3 启动线程的方法 start() #

前文已经演示过了，之前我们已经看到了如何通过重写 run 方法创建一个线程对象，但线程对象被创建出来并不意味着线程就开始运行了。重写 run 方法是提供给线程要做的事情的指令清单。而调用 start() 方法，线程才能真正独立去执行，调用 start 方法, 才真的在操作系统的底层创建出一个线程。

# 3.4 线程睡眠 sleep() #

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

如下代码：

java复制代码public static void main(String[] args) throws InterruptedException {
        long begin = System.currentTimeMillis();
        Thread.sleep(3000);//睡眠当前线程
        long end = System.currentTimeMillis();
        System.out.println(end - begin);
    }

结果：

![format_png 7][]

它的一些更详细内容后文介绍。

# 3.5 中断线程 #

这里的中断不是马上就中断的意思，具体的我们看下面的案例。

这里有两个线程，通过一个线程来中断另一个线程，这里先不使用Thread的方法。

Java复制代码public class Main {
        
        public static volatile boolean flag = true;
        
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(){
                @Override
                public void run(){
                    // flag 是中断标记
                    while(flag){
                        try {
                            Thread.sleep(500);//睡眠
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("Hi");
                    }
                }
            };
            //开启线程
            thread.start();
    
            //中断线程
            Thread.sleep(3000); //睡眠 3 秒
            flag = false;//更改标记
            System.out.println("开始中断线程");
        }
    }

（volatile的作用这里不作介绍，后面会持续更新。）

结果：

![format_png 8][]

你会发现，这里的中断就是改变标记位的值，并且这里是有延迟的，只有sleep睡眠结束的时候才能结束线程。

所以就可以使用Thread提供的方法，即： isInterrupted()或者interrupted()，它们的优点就是能立刻唤醒睡眠的线程，看下面的案例。

<table> 
 <tbody> 
  <tr> 
   <td> <p>方法</p> </td> 
   <td> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public void interrupt()</p> </td> 
   <td> <p>中断对象关联的线程，如果线程正在阻塞，则以异常方式通知， 否则设置标志位</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public static boolean interrupted()</p> </td> 
   <td> <p>判断当前线程的中断标志位是否设置，调用后清除标志位</p> </td> 
  </tr> 
  <tr> 
   <td> <p>public boolean isInterrupted()</p> </td> 
   <td> <p>判断对象关联的线程的标志位是否设置，调用后不清除标志位</p> </td> 
  </tr> 
 </tbody> 
</table>

这里的标志位的详细介绍在后面。

java复制代码    public static void main(String[] args) throws InterruptedException {
    
            Thread thread = new Thread(){
                @Override
                public void run(){
                    // flag 是中断标记
                    while(!Thread.currentThread().isInterrupted()){
                        try {
                            Thread.sleep(500);//随眠
                        } catch (InterruptedException e) {
                            e.printStackTrace();//打印报错信息
                        }
                        System.out.println("Hi");
                    }
                }
            };
            //开启线程
            thread.start();
    
            Thread.sleep(3000); //睡眠 3 秒
            thread.interrupt();//中断 thread 线程，把标记位置为true。
            System.out.println("开始中断线程");
        }

这里解释一下!Thread.currentThread().isInterrupted()，Thread.currentThread()的作用是返回当前线程对象的引用，跟this差不多：

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

isInterrupted()：如果当前线程被中断就返回true，否则返回false。

这里的中断要根据中断标志位来看，中断标志位（interrupt flag）是线程的内部状态之一，实际上是存在于线程的内部数据结构中。\*\*具体来说，中断标志位是线程对象的一个成员变量，用于表示线程的中断状态。\*\*这个标志位在线程创建时被初始化为false，当调用线程的interrupt()方法时，中断标志位会被设置为true，表示线程被中断。

Thread.currentThread().isInterrupted()，这里就表示当前线程是否中断，如果中断就返回true，否则false。最后在前面加上一个!，来作为while的条件，那就是中断就返回false，否则true。

最后我们来看看结果，注意，上面我们已经调用了thread.interrupt()，所以预期是sleep抛异常，然后结束循环（结束线程），

结果：

![format_png 9][]

为什么这里程序没有结束呢？我们来慢慢分析，没结束显然是while循环的条件还是ture，那么Thread.currentThread().isInterrupted()的值就是false，就表示线程不是处于中断状态，What？我们不是已经调用了interrupt()方法了吗？

原因就是：当线程被阻塞时，比如调用了sleep()、join() 或 wait()方法，如果收到了中断请求，这些方法会抛出 InterruptedException 异常，**并清除中断状态！**，这里的清除中断状态就是把标记位置为false，表示该线程没有被中断。

如果解决这个问题呢？直接在catch中加上break就行了。

java复制代码    public static void main(String[] args) throws InterruptedException {
    
            Thread thread = new Thread(){
                @Override
                public void run(){
                    // flag 是中断标记
                    while(!Thread.currentThread().isInterrupted()){
                        try {
                            Thread.sleep(500);//随眠
                        } catch (InterruptedException e) {
                            //这里进行善后处理
    
                            break;
                        }
                        System.out.println("Hi");
                    }
                }
            };
            //开启线程
            thread.start();
    
            //中断线程
            Thread.sleep(3000); //睡眠 3 秒
            thread.interrupt();//中断 thread 线程
            System.out.println("开始中断线程");
        }

![format_png 10][]

像这样做的优点有哪些呢？线程可以根据自己的逻辑来处理中断请求，比如结束循环、**关闭资源**或者忽略。

总结：先觉条件，调用interrupt()；

1.  如果线程因为调用 wait/join/sleep 等方法而阻塞挂起，则以InterruptedException异常的形式通知，重置中断标记。这时要不要结束线程取决于 catch 中代码的写法。可以选择忽略这个异常，也可以跳出循环结束线程。
2.  如果没有 wait/join/sleep 等方法，
3.  Thread.interrupted() 判断当前线程的中断标志是否被设置，判断后，重置中断标志。
4.  Thread.currentThread().isInterrupted() 判断当前线程的中断标志是否被设置，不重置除中断标志。

# 3.6 等待线程 join() #

有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。

<table> 
 <tbody> 
  <tr> 
   <td> <p>方法</p> </td> 
   <td> <p>描述</p> </td> 
  </tr> 
  <tr> 
   <td> <p>join()</p> </td> 
   <td> <p>等待该线程执行完成</p> </td> 
  </tr> 
  <tr> 
   <td> <p>join(long millis)</p> </td> 
   <td> <p>最多等待指定的毫秒数，如果线程在该时间内没有执行完成，当前线程将继续执行</p> </td> 
  </tr> 
  <tr> 
   <td> <p>join(long millis, int nanos)</p> </td> 
   <td> <p>最多等待指定的毫秒数和纳秒数，如果线程在该时间内没有执行完成，当前线程将继续执行</p> </td> 
  </tr> 
 </tbody> 
</table>

java复制代码public class Main {
        public static void main(String[] args) {
            Thread thread = new Thread(){
                @Override
                public void run(){
                    for (int i = 0; i < 9; i++) {
                        System.out.println("thread");
                    }
                }
            };
    
            thread.start();//开启线程
    
            System.out.println("join()前");
            try {
                thread.join();//先等 thread 线程执行完
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("join()后");
        }
    }

![format_png 11][]

如果在join()之前thread线程已经执行完了的话，join()就不会阻塞了。

这些join()方法提供了线程之间的协同执行机制，允许一个线程等待另一个线程执行完成后再继续执行。这对于需要线程执行顺序或线程之间的依赖关系的场景非常有用。

[format_png]: https://img-blog.csdnimg.cn/img_convert/8f8e412ef21346a961cbeab81f6bc480.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/90331e11444c03bd0b43cb48bffacc27.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/501ee57b81831ec8bec0e1d90bf3ef88.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/58fd1431fc5162ccabc2a3c278144a88.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/316758ab0f91138c3296747154621036.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/d42ca75915ea3d8936cf58c8efffaffd.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/d90d40a63721d01a1e1cddad2856bda4.webp?x-oss-process=image/format,png
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/5f2de071495da29fbe49b3b8941a1583.webp?x-oss-process=image/format,png
[format_png 8]: https://img-blog.csdnimg.cn/img_convert/74f9b532214fa54f7282a0def5c78eb7.webp?x-oss-process=image/format,png
[format_png 9]: https://img-blog.csdnimg.cn/img_convert/7c1be7d7dc09b3820393368f5dc4522f.webp?x-oss-process=image/format,png
[format_png 10]: https://img-blog.csdnimg.cn/img_convert/25e4874160e95d582c313450df9a2f8a.webp?x-oss-process=image/format,png
[format_png 11]: https://img-blog.csdnimg.cn/img_convert/0f37ec8f1bd1b2cfd480801914492055.webp?x-oss-process=image/format,png