Java线程(创建线程、线程的状态，常见使用方法，如何优雅的停止线程)

已于 2022-06-12 14:58:20 修改
阅读量765 收藏 2
点赞数
分类专栏： JUC编程篇 文章标签： java android 开发语言
于 2022-06-12 14:16:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjj_flower/article/details/125245023
版权

1、开始创建和运行一个线程

方法一：直接使用Thread创建一个线程

 // 构造方法的参数是给线程指定名字，推荐
 Thread t1 = new Thread("t1") {
  @Override
  // run 方法内实现了要执行的任务
  public void run() {
  log.debug("hello");
  }
 };
 t1.start();

可以直接通过new Thread() 创建一个线程，默认创建的线程是非守护线程，代码中t1为线程的名称，因为Thread类实现了Runnable接口，所以必须重写run方法，run方法中的代码就是线程的运行内容。人后通过start方法就可以启动该线程了。

运行结果如下：

 19:19:00 [t1] c.ThreadStarter - hello //打印hello

注意：run方法并不是开启该线程，必须执行了start方法，才能运行该线程，运行代码即为run方法中的内容。

考虑到Runnable接口只有一个run方法，则Runnable为函数式接口，则实现的Thread可以使用拉姆达(lambda)表达式，结果如下

 Thread t1 =  new Thread(() -> {
     log.debug("running...");
 });
 t1.start(); //实现的效果相同

方法二：使用 Runnable 配合 Thread（推荐使用）

为了提高代码的可用性，我们一般将线程的创建(线程)与只要执行的内容(内容)分开

  • Thread 代表线程

  • Runnable 可运行的任务（线程要执行的代码）

具体实现如下：

 // 创建任务对象
 Runnable task = new Runnable() {
      @Override
      public void run() {
      log.debug("hello");
      }
 };
 // 参数1 是任务对象; 参数2 是线程名字，推荐
 Thread t2 = new Thread(task, "t2");
 t2.start();

输出的结果如下：

 19:19:00 [t2] c.ThreadStarter - hello

同样可以使用lambda表达式简化，如下：

 // 创建任务对象
 Runnable task = () -> log.debug("hello");
 // 参数1 是任务对象; 参数2 是线程名字，推荐
 Thread t2 = new Thread(task, "t2");
 t2.start(); //实现的结果完全相同

方法三：FutureTask配合 Thread

FutureTask可以接收Callable类型的参数，Callable可以用来处理具有返回值的线程；

具体如下：

 // 创建任务对象
 FutureTask<Integer> task3 = new FutureTask<>(() -> {
  log.debug("hello");
  return 100;
 });
 // 参数1 是任务对象; 参数2 是线程名字，推荐
 new Thread(task3, "t3").start();
 // 主线程阻塞，同步等待 task 执行完毕的结果
 Integer result = task3.get();
 log.debug("结果是:{}", result);

输出的结果如下：

 19:22:27 [t3] c.ThreadStarter - hello
 19:22:27 [main] c.ThreadStarter - 结果是:100

Runnable接口没有返回值，Callable接口有返回值

在创建线程是，建议使用Runnable或Callable接口，这样更加容易与线程池或更加高级的API配合使用；他们使线程的任务与线程的创建分开了，使用起来更加灵活；

2、线程的常见方法

方法名是否静态（STATIC）功能说明注意
start()启动一个新线程，在新的线程运行 run 方法中的代码start 方法只是让线程进入就绪，里面代码不一定立刻运行（CPU 的时间片还没分给它）。每个线程对象的start方法只能调用一次，如果调用了多次会出现IllegalThreadStateException
run()线程执行start方法后会执行的方法如果在构造 Thread 对象时传递了 Runnable 参数，则线程启动后会调用 Runnable 中的 run 方法，否则默认不执行任何操作。但可以创建 Thread 的子类对象，来覆盖默认行为
join()等待线程结束
join(long n)有期限的等待线程结束，当等待n毫秒后若线程没有结束不会继续等待。
getId()获取线程的长整形的id
getName()获取线程名
setName(String name)修改线程名
getPriority()获取线程优先级
setPriority(int)修改线程优先级java中规定线程优先级是1~10 的整数，较大的优先级能提高该线程被 CPU 调度的机率
getState()获取线程状态Java 中线程状态是用 6 个 enum 表示，分别为：NEW, RUNNABLE, BLOCKED, WAITING,TIMED_WAITING, TERMINATED
isInterrupted()判断是否被打不会清除 打断标记
isAlive()线程是否存活（还没有运行完毕）
interrupt()打断线程如果被打断线程正在 sleep，wait，join 会导致被打断的线程抛出 InterruptedException，并清除 打断标记 ；如果打断的正在运行的线程，则会设置 打断标记 ；park 的线程被打断，也会设置 打断标记
interrupted()判断当前线程是否被打断会清除 打断标记
currentThread()获取当前正在执行的线程
sleep(long n)让当前执行的线程休眠n毫秒，休眠时让出 cpu
yield()提示线程调度器让出当前线程对CPU的使用主要是为了测试和调试

3.3、部分方法的说明

3.3.1、start()和run()方法

  • 直接调用 run 是在主线程中执行了 run，没有启动新的线程

  • 使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

3.3.2、sleep()和yield()

sleep():

  1. 调用sleep()方法会让线程从Runnable(运行)状态转化为Timed Waiting(阻塞)状态；

  2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException；

  3. 睡眠结束后的线程未必会立刻得到执行；

  4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield():

  1. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程

  2. 具体的实现依赖于操作系统的任务调度器

线程优先级:

  • 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它

  • 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用

3.3.3、join 方法详解

为什么需要join()方法？

查看下面代码

 static int r = 0;
 public static void main(String[] args) throws InterruptedException {
      test1();
 }
 private static void test1() throws InterruptedException {
      log.debug("开始");
      Thread t1 = new Thread(() -> {
          log.debug("开始");
          sleep(1);
          log.debug("结束");
          r = 10;
      });
      t1.start();
      log.debug("结果为:{}", r);
      log.debug("结束");
 }

分析说明：

在上述代码中，因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10；而主线程一开始就要打印 r 的结果，所以只能打印出 r=0，那么怎样才能让主线程准确的打印出我们需要的结果r=10呢？

问题解决：

用 join()方法，加在 t1.start() 之后即可，即在 t1.start() 加上t1.join()。这样当主线程执行到t1.join()，就会等待t1线程执行结束之后才会继续向下执行。

用 sleep 行不行？为什么？

若在 t1.start()之后使用Thread.sleep(m)，可以实现相应的结果，但是很不好，应为我们不知道t1线程需要执行的具体时间大概是多少；若m<t1运行的时间时，还是会得到错误的结果；若m>t1运行不得时间时，就会让主线程继续陷入阻塞状态，影响效率，所以，在此处不能使用sleep()方法。

3.3.4、 interrupt() 方法详解

打断 sleep()，wait()，join() 的线程

这几个方法都会让线程进入阻塞状态

打断 sleep() 的线程, 会清空打断状态，以 sleep ()为例

 private static void test1() throws InterruptedException {
      Thread t1 = new Thread(()->{
          Thread.sleep(1000);
          }, "t1");
      t1.start();
      Thread.sleep(500);
      t1.interrupt();
      log.debug(" 打断状态: {}", t1.isInterrupted());
 }

输出结果：

 java.lang.InterruptedException: sleep interrupted
      at java.lang.Thread.sleep(Native Method)
      at java.lang.Thread.sleep(Thread.java:340)
      at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
      at cn.itcast.n2.util.Sleeper.sleep(Sleeper.java:8)
      at cn.itcast.n4.TestInterrupt.lambda$test1$3(TestInterrupt.java:59)
      at java.lang.Thread.run(Thread.java:745)
 21:18:10.374 [main] c.TestInterrupt - 打断状态: false

打断正常运行的线程, 不会清空打断状态

 private static void test2() throws InterruptedException {
      Thread t2 = new Thread(()->{
          while(true) {
              Thread current = Thread.currentThread();
              boolean interrupted = current.isInterrupted();
              if(interrupted) {
                  log.debug(" 打断状态: {}", interrupted);
                  break;
              }
          }
      }, "t2");
      t2.start();
       Thread.sleep(500);
      t2.interrupt();
 }

输出：

 20:57:37.964 [t2] c.TestInterrupt - 打断状态: true

3.4、不推荐使用的方法-停止和回复线程的方法

stop()：停止线程运行

stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，

其它线程将永远无法获取锁；

suspend() ：挂起(暂停)线程运行

resume()：恢复线程运行

推荐使用两阶段终止模式暂停线程

在一个线程 T1 中如何“优雅”终止线程 T2？这里的【优雅】指的是给 T2 一个料理后事的机会。

原理如下：

实现方法1：利用isInterrupted()方法

interrupt 可以打断正在执行的线程，无论这个线程是在 sleep，wait，还是正常运行

实现代码如下：

 class TPTInterrupt {
     private Thread thread;
     public void start(){
         thread = new Thread(() -> {
             while(true) {
                 Thread current = Thread.currentThread();
                 if(current.isInterrupted()) {
                     log.debug("料理后事");
                     break;
                 }
                 try {
                     Thread.sleep(1000);
                     log.debug("将结果保存");
                 } catch (InterruptedException e) {
                     current.interrupt();
                 }
                 // 执行监控操作 
             }
         },"监控线程");
         thread.start();
     }
     
     
     public void stop() {
         thread.interrupt();
     }
 }

调用暂停方法

     public static void main(String[] args) throws InterruptedException {
 ​
         TPTInterrupt t = new TPTInterrupt();
         t.start();
         Thread.sleep(3500);
         log.debug("stop");
         t.stop();
 ​
     }

实现结果，这样就可以在巧妙的停止线程了，还可以在停止之前做中做最后的事。

 12:10:53.249 c.TPTInterrupt [监控线程] - 将结果保存
 12:10:54.252 c.TPTInterrupt [监控线程] - 将结果保存
 12:10:55.254 c.TPTInterrupt [监控线程] - 将结果保存
 12:10:55.757 c.TestTPTInterrupt [main] - stop
 12:10:55.757 c.TPTInterrupt [监控线程] - 料理后事

实现方法2： 利用停止标记停止一个线程

 // 停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
 // 我们的例子中，即主线程把它修改为 true 对 t1 线程可见
 @Slf4j(topic = "c.TPTVolatile")
 class TPTVolatile {
     private Thread thread;
     private volatile boolean stop = false;
     public void start(){
         thread = new Thread(() -> {
             while(true) {
                 Thread current = Thread.currentThread();
                 if(stop) {
                     log.debug("料理后事");
                     break;
                 }
                 try {
                     Thread.sleep(1000);
                     log.debug("将结果保存");
                 } catch (InterruptedException e) {
                 }
                 // 执行监控操作
             }
         },"监控线程");
         thread.start();
     }
     public void stop() {
         stop = true;
         thread.interrupt();
     }
 }
 ​
 //************************************************************************************
 //调用
     public static void main(String[] args) throws InterruptedException {
 ​
         TPTVolatile t = new TPTVolatile();
         t.start();
         Thread.sleep(3500);
         log.debug("stop");
         t.stop();
 ​
     }
 ​
 //*************************************************
 //输出结果
 12:17:07.660 c.TPTVolatile [监控线程] - 将结果保存
 12:17:08.672 c.TPTVolatile [监控线程] - 将结果保存
 12:17:09.685 c.TPTVolatile [监控线程] - 将结果保存
 12:17:10.158 c.TestTPTInterrupt [main] - stop
 12:17:10.158 c.TPTVolatile [监控线程] - 料理后事
 ​
 Process finished with exit code 0
 ​
 ​

逐步绽放的海棠花
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java并发基本概念、线程启动终止
qq_44027353的博客
03-30 434
cpu调度中我们知道cpu是频繁切换不同的线程执行的，线程在使用cpu执行时会使用cpu的寄存器与程序计数器的，如果出现了线程切换，那么cpu就会把当前线程在寄存器与程序计数器中的上下文数据拷贝到内存中去，然后再执行另一个的线程，此时会从内存中把另一个线程的上下文在cpu寄存器中进行恢复。这种情况下，使用中断会更好，因为，方法如果被调用则立刻强制停止该线程的执行，这种方式本身就是不安全的，比如正在往磁盘中写一个文件，强制终止线程运行后那么连文件的结束符都不会写，就造成了文件损坏。
java 线程的创建、查看、杀死、运行原理
丨康有为丨的博客
07-24 193
java多线程与高并发（二）java 线程的创建、查看、杀死、运行原理
java 创建线程的方式?停止线程的方式?
m0_50163856的博客
03-23 2749
======创建线程的方式====== 继承Thead类,重写run()方法 实现Runnable类,重写run()方法 使用lombda 实现Callable类,重写call()方法 使用线程池 ======停止线程的方式====== 使用stop()方法 使用suspend()和resume()方法 配合volatile 使用interrupt()方法 什么都不做，让线程自然结束
Java线程的创建、启动和停止
jim8973的博客
04-07 629
创建线程的两种种方式(Only Two) 1、用Thread的方式实现线程 public class ThreadStyle extends Thread{ @Override public void run() { System.out.println("用Thread类实现线程"); } public static void main(String[] args) { new ThreadStyle().start(); } }
Java 创建线程/停止线程
08-23 91
继承 Thread 类 class MyThread1 extends Thread{ @Override public void run(){ System.out.println("继承 Thread ..."); } } public class Test1 extends Thread { public s...
Java线程的创建、运行、生命周期以及常用方法
y516369的博客
08-26 458
Java线程的创建、运行、生命周期以及常用方法
Java 多线程的创建及方法、优先级.docx
最新发布
01-16
- **实现 Runnable 接口**：这是创建线程的常见方式，你的类实现 `Runnable` 接口，然后提供一个 `run()` 方法。创建线程时，将实现 `Runnable` 的对象传递给 `Thread` 类的构造函数。例如： ```java class ...
Java使用Callable和Future创建线程操作示例
08-25
Java使用Callable和Future创建线程操作示例主要介绍了Java使用Callable和Future创建线程操作，结合实例形式分析了java使用Callable接口和Future类创建线程的相关操作技巧与注意事项。 首先，Java 5开始，Java提供了...
java安全停止线程的方法详解
08-25
Java 安全停止线程的方法详解 Java 安全停止线程是 Java 编程中的一项重要技术，旨在...使用判断标志位的方法中断线程是 Java 安全停止线程的一种可靠方法。这种方法可以确保线程的安全停止，避免了线程的非正常中断。
Java中停止线程执行的方法
08-04
在Java编程中，控制线程的执行是多线程编程中的关键部分。本文将深入探讨如何在Java中正确地暂停或停止线程，以及为何不推荐使用wait()和notify()来...理解这些概念和最佳实践对于编写健壮的多线程Java程序至关重要。
Java创建子线程的两种方法
08-19
Java 创建子线程的两种方法是 Java 编程中非常重要的知识点。创建子线程的两种方法主要介绍了 Java 创建子线程的两种方法，通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。 一、继承 ...
线程停止的方式
欢迎一起学习交流
04-02 835
1.线程正常停止 建议让线程正常停止，用for循环限制次数，死循环会让CPU满。 2.使用标志位 设置一个标志位，利用条件进行判断，当不满足条件时，停止线程 public class StopTest implements Runnable{ //设置标志位 private boolean flag = true; @Override public void run() { int i = 0; //当标志位为true时，线程运行
如何优雅的创建线程
959
09-08 432
rocketmq 中 如何优雅创建线程
java thread关闭_java 线程池使用后到底要不要关闭
weixin_42497593的博客
02-24 1334
最近在开发中用到了java的线程池，然后就很疑惑这个线程池到底要不要手动关闭，感觉是要关闭的，但是没人强调线程池用完要关闭。so今天来试验下到底线程池用完要不要关闭。直接上实验代码public static void main(String[] args) throws Exception {//用于获取到本java进程，进而获取总线程数RuntimeMXBean runtimeBean = Ma...
java如何让线程停止_Java 如何正确停止一个线程
weixin_33623304的博客
02-12 208
自己在做实验性小项目的时候,发现自己遇到一个问题:如何控制线程的"死亡"?首先,如何开启一个线程呢?最简单的代码:1 public classMain {23 public static voidmain(String[] args) {45 Thread thread = new Thread(newRunnable() {6 @Override7 ...
【Java多线程与高并发】2、线程的创建、启动、停止方式
喜欢前端的后端 MelodyJerry
04-24 9644
线程的创建及启动方式 import java.util.concurrent.*; public class T02_HowToCreateThread { /** * 继承 Thread, 重写 run() */ static class MyThread extends Thread { @Override public void run() { // super.run(); Syste
线程start()理解以及线程什么时候退出
皮卡丘的博客
01-06 3225
原文链接:https://blog.csdn.net/dada360778512/article/details/6965790\ java中实现多线程有两种途径： 继承Thread类或者实现Runnable接口。 1.Runnable是接口，建议用接口的方式生成线程，因为接口可以实现多继承，况且Runnable只有一个run方法，很适合继承。 在使用Runnable的时候需要先new一个实现Ru...
java 多线程&停止线程的方法——19
爱的叹息的专栏
06-06 1802
在Java中有3种方法可以使正在运行的线程终 止运行 1）使用退出标志使线程正常退出。 2）使用stop()方法强行终止线程，但是这个 方法不推荐使用，因为stop()和suspend()、 resume()一样，都是作废过期的方法，使用它们可 能发生不可预料的结果。 3）使用interrupt()方法中断线程。...
Java多线程之常用的相关方法总结（线程停止、线程休眠、线程礼让、线程优先级、守护线程等等）
熊凯瑞的博客
12-05 685
setPriority(int newPriority) 更改线程的优先级 static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠 void join() 等待该线程终止 static void yield() 暂停当前正在执行的线程对象，并执行其他线程 void interrupt() 中断线程，别用这个方式 boolean isAliv
Java线程创建、同步与状态详解：从基础到实战
使用多线程时，考虑到创建线程的成本低，优先选择线程而非进程来实现并发。 本章节深入讲解了线程的创建、管理以及同步机制，这对于理解和应用多线程编程至关重要，有助于设计高效、稳定的并发程序。同时，理解进程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值