Thread类的一些用法

已于 2024-01-31 21:39:16 修改
阅读量857 收藏 21
点赞数 23
分类专栏： Java 文章标签： java 开发语言
于 2024-01-31 15:40:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67872788/article/details/135750993
版权

在Java中，Thread类是一个实现多线程编程的一个基础类。我们可以对线程有多种操作，比如创建线程，终止线程，休眠线程，等待线程，获取线程的实例等。下面将逐个介绍以上操作。

1. 创建线程

创建线程有多种方法，主要有：（1）继承Thread类，重写run方法；（2）实现Runnable，重写run方法；（3）继承Thread，重写run，使用匿名内部类；（4）实现Runnable，重写run，使用匿名内部类；（5）使用Lambda表达式（最常用）。

1.1 继承Thread，重写run()

public class MyThread1 extends Thread{
    //继承Thread,重写run

    @Override
    public void run(){

            System.out.println("this is thread!");
        
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread1();

        t.start();//调用了系统的API，在系统内部创建了新的线程，这个线程会调用Thread类中的run方法，实现了并发编程
        
        System.out.println("this is main!");
        
    }
}

1.2  实现Runnable，重写run()

public class MyThread2 implements Runnable{
    @Override
    public void run() {
            System.out.println("this is thread!");
    }
    
    public static void main(String[] args){
        //实现runnable，重写run
            Runnable runnable = new MyThread2();
            Thread t = new Thread(runnable);
            t.start();
            System.out.println("this is main!");
    }
}

1.3 继承Thread，重写run()，使用匿名内部类

public class MyThread3 extends Thread{
    //继承Thread,重写run，使用匿名内部类
    public static void main(String[] args) {
        Thread t = new MyThread3(){
            @Override
            public void run() {
                    System.out.println("this is thread!");
            }
        };
            t.start();
            System.out.println("this is main!");
    }
}

1.4 实现Runnable，重写run()，使用匿名内部类

public class MyThread4{
    public static void main(String[] args) {
        //实现runnable，重写run，使用匿名内部类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                    System.out.println("this is thread!");
            }
        };
        Thread t = new Thread(runnable);
        t.start();
            System.out.println("this is main!");
    }
}

1.5 使用Lambda表达式

public class MyThread5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("this is thread!");
        });
        t.start();
        System.out.println("this is main!");
    }
}

以上是五种创建线程的方式，start()是线程的入口方法，t.start()调用了系统的API，在系统中创建了一个新的线程，这个线程会调用Thread的run()方法，实现了并发编程，能交替执行主线程和t线程中的输出内容。

9c67a688d0a043289e42a869c276316a.png

【t.start()和t.run()的区别】 

若将t.start()更换为t.run()，t.run()不会调用系统的API，也就不会创建新的线程，因此t.run()无法实现并发编程，只能一个线程一个线程的运行，只有当前线程运行完毕后才能去执行其他线程任务。

public class MyThread5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true){
                System.out.println("this is thread!");
            }
        });
        t.run();
        //t.start();
        while (true){
            System.out.println("this is main!");
        }
    }
}

ab3b094e08fb4de7b4bae173a654f6ad.png

运行结果是无限循环输出 this is thread！

每个线程是一个独立的执行流，t.start()可以实现并发编程，能交替运行两个线程，即能交替输出两个线程的输出内容。

public class MyThread5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true){
                System.out.println("this is thread!");
            }
        });
        //t.run();
        t.start();
        while (true){
            System.out.println("this is main!");
        }
    }
}

23a7c74b20da40618dcc7bde0efd7080.png

2. 休眠线程 和 等待线程

2.1 休眠线程

可以使用Thread类的sleep(毫秒)方法，来使一个线程休眠一定的时间，时间到之后，该线程就能继续被调度执行了 

public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            System.out.println("t线程执行中！");

        });
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("执行完毕");
    }
}

8e42725e55c34a95a185638ab8669b19.png

2.2 等待线程

使用Thread类的无参版本的join()方法，可让 某一个线程 等待 另一个线程执行结束后再执行，该方法也就控制着线程的执行结束的顺序。

在哪个线程中调用了join方法，则哪个线程就等待另一个线程先执行。比如 在main中调用t.jion()，则main线程就等待t线程先执行。

代码示例如下：

public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            System.out.println("t线程执行中！");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        t.start();
        t.join();
        System.out.println("main线程执行中");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("执行完毕");
    }
}

e9a8267e0ec5493b9a691037cba3b312.png

这样就可以控制线程的结束顺序，一个线程等待另一个线程执行结束后再执行。

由于线程调度是随机的，且创建一个新的线程有一定系统开销，若不使用join方法，就会先去执行main线程的任务了。

df51048dfc304adb80385eb4a0075eaa.png

3. 终止线程 和 获取线程实例

Thread内部有一个标志位，该标志位就是用来判定当前线程是否结束，t.interrupt()就可将t线程内部的标志位设置为true，这样就可以终止t线程. 代码如下：

其中，Thread.currentThread()是用来获取当前线程的实例。

哪个线程调用了Thread.currentThread()，就返回哪个线程的对象，如下面代码中，在t线程中调用了Thread.currentThread()，则Thread.currentThread()就返回t线程的对象，也就是t。因此while循环条件的代码中Thread.currentThread()就获取到了当前线程的对象t。

【终止一个线程的两步操作】：

  (1) 主线程main中 t.interrupt()，此操作就将t线程中的标志位设置为true。

  (2) Thread.currentThread().isInterrupted()，此操作用来判定当前线程是否终止。

  以上两步操作就成功将t线程终止了。

public class Demo2 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("t线程工作中！");
            }
        });
        t.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        
        t.interrupt();
        System.out.println("成功终止t线程！");
    }
}

ab7db94266874b309000cd0327d4115e.png 

若t线程中有sleep()方法，如以下代码，t.interrupt()会触发sleep内部中的一个异常，且会重置线程内部的标志位，即将刚刚设置的标志位true还原为false，这样线程就不会终止了（catch到的是e.printStackTrace()基础上）。这样的话即使调用了t.interrupt()，t线程也不会终止。这种情况就是将主动权交给我们自己，若确定要终止线程，就在catch中加上 break，就可终止t线程了。

public class Demo2 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("t线程工作中！");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                   //throw RuntimeException(e);
                    e.printStackTrace();
                    //break;
                }
            }
        });
        t.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        t.interrupt();
        System.out.println("成功终止t线程！");
    }
}

 8af7c2120c614eb5a91d3b7e64f2d22b.png

若catch中是throw RuntimeException(e)，则会抛出运行时异常，不用加break，线程也由于异常而终止了。

1535e6b0de354c458e8deaf00cb13725.png

 

 

小黄hope
关注
专栏目录
java thread类有哪些方法_thread类有哪些方法
weixin_39822923的博客
02-13 3064
Thread类中的方法可分为实例方法和静态方法，其中实例方法有start()方法，run()方法等，静态方法有currentThread()方法，sleep(long millis)方法等【推荐课程：Java教程】Thread类中的实例方法start()方法这个方法的作用就是通知线程规划器此现场可以运行了。要注意，调用start方法的顺序不代表线程启动的顺序，也就是cpu执行哪个线程的代码具有不确...
Thread类的构造方法及常用方法
wardo_l的博客
02-28 1851
API中java.lang.Thread类定义了有关线程的一些方法，具体如下： 构造方法： public Thread()：分配一个新的线程对象。 public Thread(String name)：分配一个指定名字的新的线程对象。 public Thread(Runable target)：分配一个带有制定目标新的线程对象。 public Thread(Runable target,String name)：分配一个带有指定目标新的线程对象并指定名字。 常用方法： 1.public Str
Thread 类的基本用法——一网打尽
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
07-30 832
线程创建、线程中断、线程等待、线程休眠、获取线程实例😁这些线程的基本用法，你还记得吗🤔
Thread 类及常用的方法
weixin_46103589的博客
04-10 3055
文章目录一、Thread 的常见构造方法二、Thread 的常见属性三、创建线程四、中断线程五、线程等待六、获取线程引用七、线程休眠八、线程状态 一、Thread 的常见构造方法 方法 说明 Thread() 创建线程对象 Thread(Runnable target) 使用 Runnable 对象创建线程对象 Thread(String name) 创建线程对象并命名 Thread(Runnable target,String name) 使用 Runnable 对象创建线程对
Thread类及常见方法
buhuisuanfa的博客
12-07 3668
Thread类是JVM用来管理线程的一个类，每个线程都有唯一一个Thread对象与之对应，JVM会将这些对象组织起来，线程调度，线程管理。 我们在创建Thread的对象为什么要命名?方便我们查看信息和调试。 线程默认名叫做Thread-0, Thread-1等等，当线程比较多的时候，很难分辨线程，所以我们可以命名。getId()： ID是线程的唯一标识，不同的线程不重复 getName: 名称是我们构造方法设置的名称，如果没有设置，那就是默认名。 因为我们没有命名，所以使用的是默认名。 getStat
java的thread类_thread 类详解
weixin_34352565的博客
02-18 7600
java.lang.Thread类详解一、前言位于java.lang包下的Thread类是非常重要的线程类，它实现了Runnable接口，今天我们来学习一下Thread类，在学习Thread类之前，先介绍与线程相关知识：线程的几种状态、上下文切换，然后接着介绍Thread类中的方法的具体使用。二、线程的状态在正式学习Thread类中的具体方法之前，我们先来了解一下线程有哪些状态，这个将会有助于后面...
c++11 thread 类内使用方法和跨类使用方法
技术宅自娱自乐
12-22 8735
忘了为啥之前查的用上bind了，把项目搞完之后终于有时间建个小工程仔细试下怎么用。 Case 1 ： 根据类内函数创建thread class A { public:  A();  ~A();  void run(int i) {   cout  }  void thread_run() {   for (int i = 0; i    thread t(&A::r
python多线程：Thread类的用法
热门推荐
liulanba的博客
03-06 1万+
自定义一个Thread的子类，然后复写它的run()方法3.GIL全局解释器锁（global interpreter lock），每个线程在执行时候都需要先获取GIL，保证同一时刻只有一个线程可以执行代码，即同一时刻只有一个线程使用CPU，也就是说多线程并不是真正意义上的同时执行。Python的标准实现是CPython。CPython执行Python代码分为2个步骤：首先，将文本源码解释编译为字节码，然后再用一个解释器去 解释运行字节码。
Java Thread类的基本用法
Naion的博客
07-23 3387
简单介绍了Java中Thread类的几个基本的知识点。
【Java】线程基本使用——继承 Thread 类
兮动人
04-05 3287
1. 创建线程的两种方式 在java中线程来使用有两种方法。 继承Thread类，重写run方法 实现Runnable接口，重写run方法 2. 线程应用案例1-- 继承 Thread 类 请编写程序，开启一个线程，该线程每隔1秒。在控制台输出“瞄瞄,我是小猫咪” 对上题改进：当输出80次“瞄瞄,我是小猫咪”，结束该线程 使用JConsole 监控线程执行情况，并画出程序示意图 ...
c# Thread类的用法详解
12-16
本文将深入探讨`Thread`类的使用方法，以及如何通过它来实现线程间的交互。 首先，`Thread`类允许开发者创建具有不同特性的线程。与线程池相比，使用`Thread`类创建的线程提供了更多的控制权，比如可以设置线程的...
对python:threading.Thread类的使用方法详解
01-21
Python Thread类表示在单独的控制线程中运行的活动。有两种方法可以指定这种活动： 1、给构造函数传递回调对象 mthread=threading.Thread(target=xxxx,args=(xxxx)) mthread.start() 2、在子类中重写run() 方法 ...
Java中继承thread类与实现Runnable接口的比较
08-30
例如，在上面的代码中，我们定义了一个 MyThread 类，继承自 Thread 类，并override 了 run() 方法。在 run() 方法中，我们编写了卖票的逻辑代码。 实现 Runnable 接口 实现 Runnable 接口是 Java 中创建线程的另...
Java继承Thread类创建线程类示例
08-25
3. 使用继承Thread类的方法来创建线程时，多个线程之间无法共享线程类的实例变量。 五、总结 Java继承Thread类创建线程类是一种常见的线程编程方法。通过继承Thread类，可以创建自定义的线程类，并重写run方法来...
Java企业面试题3
最新发布
m0_74972727的博客
09-15 359
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 572
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1092
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 132
");
笔记：Centos Jdk Nginx 安装包安装命令
贰十六的博客
09-12 601
进入到usr中的src，把刚才下载的安装包拉进去。# ./configure 报错。# 将下面填写到配置最下方。# JDK 解压版 配置。# 进入环境变量配置。
Java Thread类实现时间打印
在这个例子中，`run()`方法包含一个循环，该循环会休眠1秒（`Thread.sleep(1000)`），然后使用`SimpleDateFormat`和`Date`类格式化并打印当前时间。 `SimpleDateFormat`是`java.text.SimpleDateFormat`类，用于格式...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值