Thread类的常用方法

最新推荐文章于 2024-01-20 20:42:04 发布
最新推荐文章于 2024-01-20 20:42:04 发布
阅读量233 收藏
点赞数 1
分类专栏： Java 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52019666/article/details/119427257
版权
本文详细介绍了Java中的线程管理，包括Thread类的常用构造方法和属性，如线程的ID、名称、状态和优先级。重点讨论了run()与start()的区别，以及如何获取当前线程引用、中断线程、使用join()等待线程和使线程休眠。文中通过实例展示了如何通过中断标志和异常来中断线程，以及join()和sleep()方法的使用场景。
摘要由CSDN通过智能技术生成

文章目录


Thread 类是 JVM 用来管理线程的一个类
换句话说，每个线程都有一个唯一的 Thread 对象与之关联

Thread 类的对象就是用来描述一个线程的执行流的，JVM 会将这些 Thread 对象组织起来，用于线程调度、线程管理

Thread 的常见构造方法

方法说明
Thread()创建线程对象
Thread(Runnable target)使用 Runnable 对象创建线程对象
Thread(String name)创建线程对象，并命名
Thread(Runnable target , String name)使用 Runnable 对象创建线程对象，并命名
Thread(ThreadGroup group , Runnable target)线程可以被用来分组管理，分好的组即线程组
Thread t1 = new Thread();
Thread t2 = new Thread(new MyRunnable());
Thread t3 = new Thread("这是我的名字");
Thread t4 = new Thread(new MyRunnable(), "这是我的名字");

Thread 的几个常见属性

属性获取方法
IDgetId()
名称getName()
状态getState()
优先级getPriority()
是否后台进程isDaemon()
是否存活isAlive()
是否被中断isInterrupted()
  • ID 是线程的唯一标识，不同线程不会重复
  • 名称是各种调试工具用到
  • 状态表示线程当前所处的一个情况
  • 优先级高的线程理论上来说更容易被调度到，和线程调度相关
  • 关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行。
  • 是否存活，即简单的理解，为 run 方法是否运行结束了。但是注意，此时Thread对象还没有销毁
  • 是否被中断，在下面有
public class test2 {

    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run(){
                for(int i = 0 ; i < 5 ;i++){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        System.out.println(t.getId());
        System.out.println(t.getName());
        System.out.println(t.getState());
        System.out.println(t.getPriority());
        System.out.println(t.isDaemon());
        System.out.println(t.isAlive());
        System.out.println(t.isInterrupted());

        t.start();
        System.out.println("==================");

        System.out.println(t.getId());
        System.out.println(t.getName());
        System.out.println(t.getState());
        System.out.println(t.getPriority());
        System.out.println(t.isDaemon());
        System.out.println(t.isAlive());
        System.out.println(t.isInterrupted());
    }
}

//运行结果
12
Thread-0
NEW
5
false
false
false
==================
12
Thread-0
RUNNABLE
5
false
true
false

run() 和 start() 的区别

  • 调用 start 方法才是创建了线程，有了新的执行流
  • 调用 run 方法只是一个普通的方法调用，不涉及新线程的创建（仍然是在原来的线程中）

获取当前线程的引用

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());
   }
}

中断一个线程

目前常见的有以下两种方式：

  1. 通过共享的标记来进行沟通
  2. 调用 interrupt() 方法来通知

示例一：

public class test3{

    private static class MyRunnable implements Runnable {

        public volatile boolean isQuit = false;

        @Override
        public void run() {
            while (!isQuit) {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName());
        }
    }
       public static void main(String[] args) throws InterruptedException {
        MyRunnable target = new MyRunnable();
        Thread thread = new Thread(target, "大毛");
        System.out.println(Thread.currentThread().getName());
        thread.start();
        Thread.sleep(1 * 1000);
        System.out.println(Thread.currentThread().getName());
        target.isQuit = true;
    }
}

示例2：

public class test4{
    private static class MyRunnable implements Runnable {
        @Override
        public void run() {
            // 两种方法均可以
            while (!Thread.interrupted()) {
                //while (!Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println(Thread.currentThread().getName());
                    break;
                }
            }
            System.out.println(Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyRunnable target = new MyRunnable();
        Thread thread = new Thread(target, "二毛");
        System.out.println(Thread.currentThread().getName());
        thread.start();
        Thread.sleep(1 * 1000);
        System.out.println(Thread.currentThread().getName());
        thread.interrupt();
    }
}

这里说一下第二种情况：

  1. 通过 thread 对象调用 interrupt() 方法通知该线程停止运行

  2. thread 收到通知的方式有两种：

    1. 如果线程调用了 wait / join / sleep 等方法而阻塞挂起，则以 InterruptedException 异常的形式通知，清除中断标志
    2. 否则，只是内部的一个中断标志被设置，thread 可以通过
      1. Thread.interrupted() 判断当前线程的中断标志被设置，清除中断标志
      2. Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置，不清除中断标志

示例3：

public class test5{
    private static class MyRunnable implements Runnable {
        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("通过异常收到了中断情况");
            }
            for (int i = 0; i < 5; i++) {
             System.out.println(Thread.currentThread().isInterrupted());
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyRunnable target = new MyRunnable();
        Thread thread = new Thread(target, "大明");
        thread.start();
        thread.interrupt();
    }
}

//运行结果——通过异常收到中断通知，并且标志位被清
false
false
false
false
false

示例4：

public class test6{
    private static class MyRunnable implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.interrupted());
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyRunnable target = new MyRunnable();
        Thread thread = new Thread(target, "二明");
        thread.start();
        thread.interrupt();
    }
}

//运行结果 —— 只有一开始是 true，后边都是 false，因为标志位被清
true
false
false
false
false

示例5：

public class test7{
    private static class MyRunnable implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().isInterrupted());
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyRunnable target = new MyRunnable();
        Thread thread = new Thread(target, "小明");
        thread.start();
        thread.interrupt();
    }
}

//运行结果 —— 全部是 true，因为标志位没有被清
true
true
true
true
true

方法：

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

等待一个线程 — join()

当多个线程被创建的时候，每个线程都是一个独立的执行流。这些线程中执行的先后顺序是不确定的，取决于系统的调度

等待线程机制就是无法保证哪个线程先执行，但是可以确定线程的“结束顺序”

public class test8 {

    public static void main(String[] args) throws InterruptedException {
        Runnable target = () -> {
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println(Thread.currentThread().getName());
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName());
        };
        Thread thread1 = new Thread(target, "线程1");
        Thread thread2 = new Thread(target, "线程2");
        System.out.println("线程1开始工作");
        thread1.start();
        thread1.join();
        System.out.println("线程1结束，线程2开始工作");
        thread2.start();
        thread2.join();
        System.out.println("线程2结束");
    }
}

//运行结果
线程1开始工作
线程1
线程1
线程1
线程1
线程1
线程1
线程1结束，线程2开始工作
线程2
线程2
线程2
线程2
线程2
线程2
线程2结束

因为， thread1先调用了 join()，所以要等 thread1 结束之后thread2才能开始工作

方法说明
public void join()等待线程结束
public void join(long millis)等待线程结束，最多等 millis 毫秒
public void join(long millis, int nanos)同理

休眠当前线程 — sleep()

因为线程的调度是不可控的，所以，这个方法只能保证实际休眠时间是大于等于参数设置的休眠时间的

方法说明
public static void sleep(long millis) throws InterruptedException休眠当前线程millis毫秒
public static void sleep(long millis, int nanos) throws InterruptedException可以更高精度的休眠
public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(System.currentTimeMillis());
        Thread.sleep(3*1000);
        System.out.println(System.currentTimeMillis());
   }
}

没有调用 sleep() 的线程随时可能会被调度到CPU上执行
当某线程调用sleep()后，就会进入等待状态。

【JAVA】-- 多线程Thread类的常用方法
张修宇的博客
05-17 1万+
一、Thread类的常用方法 1、start（）：启动当前线程 2、run（）：通常需要重写Thread类中的此方法，将创建的线程要执行的操作写在此方法中。 3、currentThread（）：静态方法，返回执行当前代码的线程 4、getName（）：获取当前线程的名字，与3一起使用可得到正在执行的线程的名字 5、setName（）：设置当前线程的名字 6、yield（）：释放当前cpu的执行权 7、join（）：在线程a中调用线程b的join（）；此时线程a就进入阻塞状态，直到线程b完全执行
【JavaEE】Thread 类及常用方法
保护小周ღ的博客
03-20 1972
哈喽，大家好~我是保护小周ღ，本期为大家带来的是 Java 多线程的 Thread 类，讲述了 Thread 类的常用方法及常用属性，例如：线程的 name， 如何启动线程，终止线程，等待线程…… 更多精彩敬请期待：保护小周ღ *★,°*:.☆(￣▽￣)/$:*.°★* ‘
Thread 类及常见方法
weixin_58697177的博客
07-21 1317
系统对于线程的调度是随机的，假设我们的机器上面存在很多的进程和线程，此时 CPU 调度一圈，消耗的时间可能就比较长，此时就可能导致某个线程隔了很久也没有调度上去，这个可能大多数人都遇到过这种情况：某些时候，电脑卡了，点击某个窗口，提示“未响应”，让我们选择等待还是结束进程。此时会出现这样的提示信息，意思是 isQuit 这个变量不是常量或者“实际常量”，常量就是 final 修饰的，“实际常量”是没有final修饰，但是也没有其他代码尝试修改的变量，但是我们在下面对 isQuit 进行了修改，所以不行。
thread类的方法
树皮儿
09-11 1524
        start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。 run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。 补充...
Thread类常用的方法
qq_44840148的博客
08-07 1328
文章目录1. run()与start()方法：启动线程2. get方法：获取线程标识3. currentThread()方法:返回对当前正在执行的线程对象的引用 1. run()与start()方法：启动线程 使用继承 Thread 类的方法创建新线程 从运行结果我们可以看出：虽然步骤1在步骤2前面，但是步骤2却比步骤1先执行完。 这是因为 start()方法的执行比较耗时，底层有如下过程： 1）通过 JVM 告诉操作系统创建线程 Thread 2）操作系统开辟内存并调用系统函数创建 Thre
Thread（线程）的一些常用方法的简绍
qq_58000391的博客
06-04 200
Thread类下的一些常用方法
Thread 对象的 方法
I need a job
08-28 630
############征服Python###########3 1 join
Java多线程-Thread类的常用结构及线程优先级
最新发布
01-27
本文将详细解析Thread类的常用结构以及线程优先级。 一、Thread类的常用结构 1. 线程中的构造器 - `Thread()`：创建一个没有指定名称的新线程对象。在创建Thread类的子类时，如果子类没有提供构造器，会默认调用...
多线程-Thread类及常见方法
weixin_71841320的博客
01-20 1298
Thread类是Java编程语言中的一个重要类，用于支持多线程编程。它是java.lang包中的一部分，提供了创建和管理线程的方法和功能。通过使用Thread类，可以同时执行多个任务，实现并行处理。每个线程都有独立的执行路径，可以在不同的时间段内独立运行。这使得程序能够更高效地利用计算机的资源，并提高应用程序的响应速度。Thread类提供了许多方法来管理线程的行为，例如start()方法用于启动线程，join()方法用于等待线程的结束，sleep()方法用于暂停线程的执行等等。
Thread的基本方法
shen_sty的博客
07-02 219
多线程Thread类的基本方法
Java多线程详解六 Thread类中的方法（1）
Zsiyuan的博客
06-03 226
Thread类中的start()和run()方法 start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样，当你调用run()方法的时候，只是会在原来的线程中调用，没有启动新的线程，start()方法才会启动新线程。 为什么wait,notify和notifyAll这些方法不在Thread类中 主要的原因是JAVA提供的锁是对象级的而不是线程级的，每个对象都有锁，通过线程获得，如果线程需要等待某些锁，那么调用对象中的wait()方法就有意义
java Thread类常用方法简单说明
SilenceCarrot的专栏
09-05 1503
static Thread currentThread() 返回当前正在执行的线程对象的引用； long getId() 返回该线程的标识符。  String getName() 返回该线程的名称。  int getPriority()  返回线程的优先级。  void interrupt()  中断线程。  boolean isAlive() 测试线程是否处于活动状态。 
Thread的常用方法
weixin_45768707的博客
07-18 465
当有很多线程在执行的时候我就需要使用Thread的常用方法getName()、setName()、currentThread（）等。1.此方法是Thread类的静态方法，可以直接使用Thread类调用。2.这个方法是在哪个线程执行中调用的，就会得到哪个线程对象。......
Thread的几种常用方法
weixin_58879043的博客
05-04 3883
简述线程的几种常用函数
多线程——Thread类的常用方法
gxx_csdn的博客
01-30 3429
本博客主要针对Thread类的常用的方法进行介绍，包括：构造方法、静态方法和非静态方法，作为自我总结。1. Thread类的构造方法根据Java api，Thread类的构造方法共有8个：Thread() Thread(Runnable target) Thread(Runnable target, String name) Thread(String name)----------Thread(T
python_day10 线程
weixin_30814319的博客
07-03 111
=====================threading模块 multiprocess模块的完全模仿了threading模块的接口，二者在使用层面，有很大的相似性，因而不再详细介绍 from threading import Thread import time def sayhi(name): time.sleep(2) print('%s say hello' ...
Java线程Thread类常用方法
qq_39939541的博客
07-09 1409
run()方法是Thread类中定义的线程执行逻辑的方法。当一个线程通过start()方法启动后，会自动调用run()方法来执行线程的代码逻辑。} }在上面的示例中，我们定义了一个实现了Runnable接口的MyThread类，重写了run()方法，在run()方法中输出一句话。在main()方法中，我们创建了一个Thread对象，并将MyThread对象作为参数传递给Thread的构造函数。然后，我们通过start()方法启动了该线程。
Java中Thread类及常见方法
Violet277的博客
07-08 1864
Java中Thread类中的常见方法的使用。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值