线程的状态

最新推荐文章于 2024-11-01 14:48:20 发布
最新推荐文章于 2024-11-01 14:48:20 发布
阅读量92 收藏
点赞数
分类专栏： java多线程 文章标签： java 多线程 thread 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46481563/article/details/113363265
版权

线程状态

在这里插入图片描述
在这里插入图片描述

1 线程停止

//测试停止线程
//1.建议线程正常停止  利用次数
//2.建议使用标志位
//3.不要使用过时或者不建议使用的方法

public class TestStop implements Runnable{

    //（1）设置一个标志位
    private boolean flag=true;

    @Override
    public void run() {
        int i=0;
        while(flag){
            System.out.println("run"+ i++);
        }
    }

    //（2）设置一个公开的方法停止线程
    private void stop(){
        this.flag=false;
    }


    public static void main(String[] args) {
        TestStop testStop = new TestStop();

        new Thread(testStop).start();

        for(int i=0;i<20;i++){
            System.out.println("main"+i);
            if (i==15){
                //调用stop方法切换标志位，让线程停止 跳出run
                testStop.stop();
                System.out.println("stop");
            }
        }
    }
}

2 线程休眠

  • 每个对象都要一把锁，Thread.sleep()不会释放琐
//模拟倒计时

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TreeMap;

public class TestSleep2{

    public static void tenDown() throws InterruptedException{
        int num=10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<0)
                break;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //打印当前系统时间
        Date startTime = new Date(System.currentTimeMillis());  //获取系统当前时间

        while (true){
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
            Thread.sleep(1000);
            startTime=new Date(System.currentTimeMillis());  //更新当前时间
        }
    }
}

3 线程礼让

Thread.yield()

  • 让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转换为就绪状态
  • 让CPU重新调度，礼让不一定成功
//测试礼让线程
//礼让不一定成功，要看CPU调度

public class TestYield{

    public static void main(String[] args) {
        //创建Runnable接口实现对象
		MyYield myYield = new MyYield();

        // 两个线程
        //创建线程对象，通过线程对象来开启线程  代理
		new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();

    }
}


class MyYield  implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" begin");
        Thread.yield();  //线程礼让  礼让不成功 直接开始停止   礼让成功 开始后让其他线程跑
        System.out.println(Thread.currentThread().getName()+" end");
    }
}

4 线程强制执行

Thread.join()

//测试join方法

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("vip"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {

        //创建Runnable接口实现对象
        TestJoin testJoin = new TestJoin();
        //创建线程对象，通过线程对象来开启线程  代理
        Thread thread = new Thread(testJoin);  //thread代理testJoin

        thread.start();

        //
        for (int i = 0; i < 100; i++) {

            System.out.println("main"+i);

            if (i==20){
                thread.join();  //强制主线程暂停 让其他线程执行
            }
        }



    }
}

5 线程状态观察

Thread.State

线程可以处于以下状态之一：

（1）NEW

尚未启动的线程处于此状态

（2）RUNNABLE

在java虚拟机中执行的线程处于此状态

（3）BOLCKED

被阻塞等待、监视器锁定的线程处于此状态

（4）WAITING

正在 等待另一个线程执行特定动作 的线程处于此状态

（5）TIMED_WAITING

正在 等待另一个线程执行动作 达到 指定等待时间 的线程处于此状态

（6）TERMINATED

已退出的线程处于此状态

  • 监测线程状态

    public class TestState{

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("//");
        });

        //状态观察
        Thread.State state = thread.getState();
        System.out.println(state);  //还未调用start9()  所以state 为 NEW

        //观察启动后
        thread.start();  //启动线程
        state = thread.getState();
        System.out.println(state);  //调用start9()  所以state 为 RUNNABLE

        //当子线程重写的run方法执行完后，线程就停住了
        while (state!=Thread.State.TERMINATED){  //只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();  //更新线程状态
            System.out.println(state);  //调用start9()  所以state 为 Run
        }

//        thread.start();//线程停止之后就退出 无法调用start
        //线程只能启动一次  死亡之后的线程不能再启动

    }
}


//    @Override
//    public void run() {
//        for (int i = 0; i < 5; i++) {
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println("//");
//        }

//    相当于  Lamda表达式
//            () -> {
//        for (int i = 0; i < 5; i++) {
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        }
//        System.out.println("//");
//    }

6 线程的优先级

  • java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，调度器按照优先级决定应该调度哪个线程执行

  • 线程优先级用1~10数字表示

    • Thread.MIN_PRIORITY=1;
    • Thread.MAX_PRIORITY=10;
    • Thread.NORM_PRIORITY=5;

  • 使用 getPriority()和setPriority(int p) 获取和改变优先级

//测试线程的优先级
//优先级高的线程 大概率会先启动 不一定会最先启动
public class TestPriorty {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority());

        MyPriorty myPriorty=new MyPriorty();

        Thread t1=new Thread(myPriorty,"t1");
        Thread t2=new Thread(myPriorty,"t2");
        Thread t3=new Thread(myPriorty,"t3");
        Thread t4=new Thread(myPriorty,"t4");

        //先设置优先级再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(10);
        t4.start();

    }
}

class MyPriorty implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority());
    }
}

7 守护线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 例如：后台记录操作日志，监控内存，垃圾回收等
//测试守护线程
//上帝守护你

public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();

        Thread thread = new Thread(god);  //代理
        thread.setDaemon(true);  //默认为false  true为守护线程  不用等待守护线程执行完毕

        thread.start();

        You you = new You();
        new Thread(you).start();  //用户线程停止

    }
}

//my
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("happy");
        }
        System.out.println("bye=================================");
    }
}

//God
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("bless");
        }
    }
}
枫叶精灵s
关注
专栏目录
python 获取子线程状态_python线程状态
weixin_33365214的博客
01-13 3368
python怎么判断线程的状态python中如何在父线程中检测其子线程是否处于运行状态子线程有一个方法 is_alive() 运行时会返回Bool值Truepython 在线程函数中如何实现线程的暂停、恢复和终我们都知道python中可以是threading模块实现多线程, 但是模块并没有提供暂停, 恢复和停止线程的方法, 一旦线程对象调用start方法后, 只能等到对应的方法函数运行完毕. 也就...
java多线程编程02 -暂停线程&yield方法&优先级&守护进程
lonelyVM的博客
12-17 200
-暂停线程 suspend() 可以暂停线程， resume()恢复线程的执行。 suspend() 其实已经是过期作废的方法，极易造成公共的同步对象的独占，使得其他线程无法访问公共的同步对象。 独占 例子1： 在一个类Tee里面，给一个方法上了锁 synchronized public void inStr() { ++i; Thread.currentThread().suspen...
Java多线程详解（三）------ 停止线程及守护线程
naruto227的博客
11-19 544
文章目录1 停止不了的线程2 判断线程是否是停止状态2.1 interrupted方法2.2 isInterrupted方法3 异常法停止线程4 在沉睡中停止5 暴力停止stop()方法6 使用return停止7 总结 1 停止不了的线程 调用interrupt()方法仅仅是在当前线程中打了一个停止的标记，并不是真正的停止线程。 public void interrupt() {} 2 判断线程是否是停止状态 2.1 interrupted方法 public static boolean interrup
java 定时器需要守护线程_守护线程和定时器
weixin_30453491的博客
02-28 364
Java中又两种线程：用户线程：普通的线程；守护线程：又可叫做后台线程，如垃圾回收线程。一般是死循环执行，等到所有的用户线程结束，守护线程就结束。如：我们需要每天的00：00就进行数据的备份，这个时候我们就需要一个定时器线程，并且将该定时器线程设置为守护线程。1.守护线程守护线程是一直执行的，即死循环，当用户线程执行完毕时，守护线程也执行完毕。如何设置线程为守护线程？在线程启动前，setDaemo...
JVM线程状态
秋枫
12-18 2925
在jvm中一共定义了6种线程状态，分别是：NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED。在Thread类中体现为下面的代码： public static enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMI...
MySQL线程状态详解
雪辉博客
04-13 3930
文章目录一、show processlist二、command命令类型三、用户线程状态 一、show processlist Id：连接进程标识符。是由 CONNECTION_ID() 函数返回的值 User：执行语句的 MySQL 用户名称。如果显示的是“system user”，它指的是由MySQL生成的非客户端线程正在执行内部任务。例如主备复制中从 库上使用的 I/O 或 SQL 线程或延迟行处理程序的线程。“unauthenticated user”指的是客户端已经和服务端建立了 TCP/IP 连
jstack线程状态分析
奋斗、
03-11 7792
jstack线程状态
jstack 线程状态详解
灵动的艺术的博客
04-22 1894
jstack 线程状态详解jatsck 用法线程状态一图以庇之系统线程状态 (Native Thread Status) jatsck 用法 #jstack -h Usage: jstack [-l] <pid> (to connect to running process) jstack -F [-m] [-l] <pid> ...
Java线程状态RUNNABLE详解
热门推荐
Mr_moving
11-03 1万+
Java虚拟机层面所暴露给我们的状态，与操作系统底层的线程状态是两个不同层面的事。具体而言，这里说的 Java 线程状态均来自于 Thread 类下的 State 这一内部枚举类中所定义的状态： 什么是 RUNNABLE？ 直接看它的 Javadoc 中的说明： 一个在 JVM 中执行 的线程处于这一状态中。（A thread executing in the Java virtual machine is in this state.） 而传统的进（线）程状态一般划分如下（基于操作系统层面，以cpu
一图流解释Java中线程状态的转换
luming的博客
05-15 1530
当线程对象被创建时，它处于新建状态。此时线程还没有开始执行。当线程对象被创建后，其他线程调用了该线程的start()方法，该线程进入就绪状态。处于就绪状态的线程可能正在等待CPU时间片，一旦获取到CPU时间片，就可以执行。线程获取到CPU时间片后，开始执行任务，处于运行状态。线程在某些情况下会进入阻塞状态，如调用sleep()方法、等待I/O操作完成、试图获取锁时被其他线程获取等。在这些情况下，线程暂时停止执行。线程进入等待状态是因为调用了wait()方法或类似的方法，该状态下线程会等待其他线程显式地唤醒。
Java线程状态转换关系实例解析
08-18
Java线程状态转换关系实例解析 Java线程状态转换关系实例解析是Java多线程编程中的一种重要概念，它指的是Java线程在不同的状态之间的转换关系。了解这些状态转换关系可以帮助开发者更好地编写多线程程序，避免线程...
Java实现监控多个线程状态的简单实例
08-31
Java实现监控多个线程状态的简单实例 Java语言中，监控多个线程状态是一个复杂的任务，需要使用Java的并发编程机制来实现。下面，我们将通过一个简单的实例来展示如何使用Java来监控多个线程状态。 知识点1：...
Java线程状态流转图
05-03
Java线程状态流转图知识点总结 Java线程状态流转图是一种用于描述Java线程生命周期中不同的状态和状态转换的图形表示方式。该图形展示了Java线程从创建到终止的整个生命周期，并详细介绍了每种状态的特点和转换...
Python实现线程状态监测简单示例
12-31
本文实例讲述了Python实现线程状态监测。分享给大家供大家参考，具体如下： # -*- coding:utf-8 -*- from threading import Thread import time def func1(): time.sleep(10) t1=Thread(target=func1) print('t1:'...
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 454
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1307
项目功能：商品分类,商品信息,用户。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1059
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
SpringSession源码分析
lkr_lkr的博客
11-01 158
默认对常规Session的理解和使用，如何使用Set-Cookie。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1264
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
Java多线程状态详解
这个例子中，通过`Thread.getState()`方法查看线程状态，但由于线程的并发性质，实际输出可能会有所不同。例如，线程可能在休眠期间就已经完成执行，因此可能不会显示"等待状态"和"阻塞状态"。 理解Java多线程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值