线程二：线程的类和常用方法

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量711 收藏 30
点赞数 30
分类专栏： Java线程 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73659744/article/details/142339102
版权

一，构造方法

方法说明
Thread()创建线程对象
Thread(Runnable target)使用 Runnable 对象创建线程对象
Thread(String name)创建线程对象，并命名
Thread(Runnable target, String name)使用 Runnable 对象创建线程对象，并命名
Thread(ThreadGroup group, Runnable target)线程可以用来被分组管理，分好的组即线程组

举例：Thread(Runnable target, String name)

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() ->{
            while(true){
               //想要执行的代码
            }
        },"线程名");

        t.start();
    }
}

执行代码，使用 JConsole 工具查看线程，发现线程名就是进程所设置的名字。

当我们没有手动设置线程名时，系统会自动为我们设置一个，默认是按照Thread-0，1，2....

线程名是可以重复的。

           

二，常见属性

属性获取方法
IDgetld()
名称getName()
状态getState()
优先级getPriority()
是否后台线程isDaemon()
是否存活isAlive()
是否被中断isInterrupted()

1. getld()

获取线程 ID。ID 是 JVM 生成的身份标识，具有唯一性。

2. getName()

获取线程名。一个进程的不同线程的线程名可能是一样的。

3. getState()

获取线程状态。Java中对线程状态又进行进一步的区分，比系统原生状态更丰富。

4. getPriority()

获取线程的优先级，在 Java 中设置优先级，会对内核调度器产生一些影响，但是由于系统的随即调度，所以这个影响并不是很明显。

5. isDaemon()

是否为守护线程，也可以叫后台线程。相应的，也有前台线程。

前台线程的运行会阻止进程结束，但是守护线程（后台线程）不会。

一般我们写入的代码默认为前台线程。

演示代码：

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() ->{
            while(true){
                System.out.println("t 线程");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}

运行结果：一直打印 " t 线程 "

上述代码一共有两个线程：main 线程和 t 线程。两个线程均为前台线程，所以当 main 线程执行结束时，t 线程阻止进程结束，还会继续执行。

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() ->{
            while(true){
                System.out.println("t 线程");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        /*setdaemon必须设置在start之前，
         true为后台，不会阻止进程结束
         非true为前台，会阻止进程结束*/
        t.setDaemon(true);

        t.start();
    }
}

运行结果：

上述代码我们将 t 线程设置为后台进程，所以当 main 线程执行结束时，t 线程不会阻止进程结束，进程就此结束。

6. isAlive()

判断内核中的线程是否还存活。

public class ThreadDemo6 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread( () -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(t.isAlive());
        t.start();
        System.out.println(t.isAlive());
        //时间参数要大于上面的，确保线程执行完毕
        Thread.sleep(2000);
        System.out.println(t.isAlive());
    }
}

运行结果：

原因解释：

        Java 代码中定义的线程对象实例的生命周期和内核中的 PCB 生命周期完全不一样。

        代码运行到 Thread t = new Thread() 时，此时只有一个 t 对象，但是内核 PCB 还没有这个线程，所以此时运行结果为 “false”；当代码运行了 t.start() 之后，才在内核中创建出这个 PCB ，所以此时运行结果为 “true”；最后线程执行完 run() ，内核中的线程也就结束了，PCB 释放，所以此时运行结果为 “false”。

7. isInterrupted()

获取线程的中断标志。

public class Threaddemo7 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread( () -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread is running");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //屏蔽是防止控制台显示异常信息
                    //e.printStackTrace();
                    //因为 t.interrupt() 会提前打断sleep的休眠期，导致清除 interrupt 的标志位
                    break;
                }
            }
            System.out.println("Thread is stopped");
        });
        t.start();

        Thread.sleep(3000);
        System.out.println("调用interrupt()前："+t.isInterrupted());
        System.out.println("线程中断");
        t.interrupt();
        System.out.println("调用interrupt()后："+t.isInterrupted());
    }
}

运行结果：

三，常用方法

1. start()

作用：线程对象只有调用了 start() 方法才会真正创建一个线程（内核中创建 PBC ）。

未调用 start() ：

public class Demo1 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("这是 t 线程");
        });

        System.out.println("这是 main 线程");
    }
}

// 运行结果：这是 main 线程

调用 start() ：

public class Demo1 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("这是 t 线程");
        });

        t.start();
        System.out.println("这是 main 线程");
    }
}

//运行结果：
//这是 main 线程
//这是 t 线程

调用两次 start() ：

public class Demo1 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("这是 t 线程");
        });

        t.start();
        t.start();
    }
}

运行结果：

代码报错：非法的线程状态。

总结：

1). 线程对象只有调用了 start() 方法后才会创建出真正的线程。

2). 一个线程对象只能调用一次 start() 方法。

2. interrupt()

作用：interrupt() 中断线程，中断线程操作实质上是修改了一下中断标示位为 true ，核心是让 run() 方法执行结束（具体实践由代码决定）。

引入标志位中断代码：

public class Demo1 {
    //引入一个标志位
    private static boolean isQuit = true;

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            //当 isQuit 为 flase 时，while 循环结束
            while (isQuit) {
                System.out.println("Thread is running");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Thread is over");
        });

        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("让 t 线程结束");
        isQuit = false;
    }
}

运行结果：

  
   注意：main 线程想要让 t 线程结束的前提是代码逻辑对此有所支持，并不是任何代码都可以实现的。

但是有时候再去自定义一个标志位有一点麻烦，此时我们就可以用 interrupt() 方法，使用 Thread 实例内部自带的标志位代替自定义的标志位。

如何使用一个 interrupt() 方法实现：

public class Threaddemo7 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread( () -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread is running");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //屏蔽是防止控制台显示异常信息
                    //e.printStackTrace();
                    //因为 t.interrupt() 会提前打断sleep的休眠期，导致清除 interrupt 的标志位
                    break;
                }
            }
            System.out.println("Thread is stopped");
        });
        t.start();

        Thread.sleep(3000);
        System.out.println("线程中断");
        t.interrupt();
    }
}

运行结果：

3. join()

作用：影响线程的先后顺序（固定条件的等待），比如现在有 t1 和 t2 两个线程，如果 t2 线程调用 t1.join 方法，则必学先让 t1 线程执行完毕，才能执行 t2 线程， join() 是可能阻塞 t2 线程，让其暂时不参与 CPU 调度。确定的不是执行顺序，而是结束顺序。

4. sleep()

令当前线程至少休眠 n 毫秒（固定时间的等待，防止无休止的休眠），其中 1000ms = 1s

5. currentThread()

获取当前线程状态。

重点：start() 和 run() 的区别：

线程中 start() 和 run() 的区别-CSDN博客

小解的秃头之旅
关注
专栏目录
〖Python语法进阶篇⑥〗- 线程的创建与常用方法
易编橙 · 终身成长社群，相遇已是上上签！
04-11 4万+
该章节我们要学习的是线程的使用，前面的学习我们知道进程的使用需要获取 CPU和内存 的资源，而线程则是利用进程的资源来执行业务，并且通过创建多个线程，对于资源的消耗相对来说会比较低，今天就来看一看线程的使用方法具体有哪些吧。
关于一个多线程类的设计方法
zhang0404的专栏
03-25 1165
设计需求描述： 如上图所示 进程A与进程B之间是进程间通信 进程B与进程C之间是网络通信 需要设计一个进程B： 进程B在serverA上，可以接收从进程A发过来的进程间消息，并且将消息处理完，通过网络发给serverB上的进程C。 serverB上的进程C收到消息，经过处理，通过网络发送回复信息给进程B，进程B处理完毕后，发送回进程A。 进程B上收到的消息，处理的过程
线程创建方式 了解线程的设计模式
qq_33598708的博客
04-25 226
1、创建线程的三种方式 1.1创建线程方式一（不推荐：由于java的单继承性）：继承Thread类，并重写run方法，调用start开启线程 //创建线程的方法一：继承Thread类，并重写run方法，调用start开启线程 //线程开启（start）不一定立即执行，由cpu调度执行 public class MyFirshThread extends Thread{ @Override public void run() { //run方法体 fo.
线程类Thread中设计模式
qianhuanci7223的博客
08-27 829
要理解这两种设计模式首先要知道创建线程的两种方式！ 创建线程有两种方式，一种是创建Thread，一种是实现Runnable接口，其实这种说法不严谨。准确的强，创建线程只有一种方式，那就是创建Thread类，而实现线程的执行单元有两种方式，一种是重写Thread类的run方法，另一种是实现runnable接口，并把Runnable实例当做参数传入到Thread构造方法中去。 1.模板设计模式 ...
多线程(一)：创建线程和线程的常用方法
热门推荐
人不风流枉少年
09-01 24万+
一：为什么要学多线程 应付面试 ：多线程几乎是面试中必问的题，所以掌握一定的基础知识是必须的。 了解并发编程：实际工作中很少写多线程的代码，这部分代码一般都被人封装起来了，在业务中使用多线程的机会也不是很多(看具体项目)，但是作为一个高级程序员如果不会多线程是说不过去的。 二：进程与线程 进程 进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统...
C++11 多线程（std::thread）详解
jcShan709的博客
07-17 11万+
注：此教程以 Visual Studio 2019 Version 16.10.3 （MSVC 19.29.30038.1) 为标准 文章目录线程？进程？多线程？什么是多线程？进程与线程的区别C++11的std::threadstd::thread常用成员函数构造&析构函数常用成员函数举个栗子例一：thread的基本使用例二：thread执行有参数的函数例三：thread执行带有引用参数的函数注意事项（剩下的内容还没写完，明天再更） 线程？进程？多线程？ 什么是多线程？ 百度百科中的解释： 多.
总结线程常用方法
m0_46383618的博客
02-05 1660
目录 一、join方法 二、interrupt方法 三、currentThread方法 四、isAlive方法 五、setDaemon方法 六、其它方法 七、终止线程——无疾而终 八、终止线程——暴毙身亡 一、join方法 join方法：执行该方法的线程进入阻塞状态，直到调用该方法的线程结束后再由阻塞转为就绪状态。 注意： 线程对象在调用join方法前必须先调用start方法，否则该线程永远不会进入执行状态。 二、interrupt方法 interrupt方法：结束线程
【面试常问】线程中常用的方法
Willing卡卡的博客
02-12 1602
在我们日常开发中线程是必不可少的，那么线程中的方法也就成了面试中的高频问题，决定整理一下；如有错误还请个位指正！
java线程执行方法_java线程的常用方法
weixin_42300040的博客
02-20 2105
java线程的常用方法编号方法说明1public void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。2public void run()如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。3public final void setName(String name)改变线程...
多线程常用方法总结
扬帆向海的博客
11-13 8501
这篇博客对多线程里面的常用方法做了总结，并且对一些方法的异同做了详细的说明。
Java多线程-Thread类的常用结构及线程优先级
01-27
理解并熟练掌握Thread类的构造器和方法，以及线程优先级的概念，对于编写高效、稳定的多线程程序至关重要。在实际开发中，应避免使用已过时的方法，合理利用线程调度机制，确保线程安全，提高程序性能。同时，对守护...
关于多线程常用方法以及对锁的控制(详解)
08-30
多线程常用方法包括sleep()、join()、yield()、wait()、notify()、notifyAll()方法等，而对锁的控制则需要使用Synchronized关键字和wait()、notify()、notifyAll()方法等。只有正确地使用这些方法和关键字，才能编写...
Java线程唤醒与阻塞常用方法共2页.pdf.zip
10-28
本文将深入探讨Java中用于线程唤醒与阻塞的常用方法，以及它们在实际编程中的应用。 1. **线程的阻塞** - `wait()`: 这个方法属于`Object`类，当一个线程调用对象的`wait()`方法时，它会释放该对象的锁并进入等待...
Java线程安全的常用类_动力节点Java学院整理
08-30
Java线程安全的常用类 Java线程安全的常用类是指在集合框架中，具有线程安全的类这些类都是jdk1.1中的出现的。在jdk1.2之后，就出现许许多多非线程安全的类。这些线程安全的类的方法都是同步的，每次只能一个访问。...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 322
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 389
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 688
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
Java分布式锁
juanmiao的专栏
10-12 690
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 524
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值