Java多线程（三）-- 线程的状态和方法

最新推荐文章于 2022-04-19 17:21:18 发布
最新推荐文章于 2022-04-19 17:21:18 发布
阅读量1.0k 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44104879/article/details/121337895
版权

多线程

线程状态

  • 线程有五大状态：创建状态、就绪状态、阻塞状态、运行状态、死亡状态；
  • new（创建状态）：线程对象一旦创建就进入到了新生状态；
  • 就绪状态：当调用 start() 方法启动线程，线程立即进入就绪状态，但是不意味着立即调度执行；
  • 运行状态：当就绪状态的线程获取到cpu资源时，线程才进入运行状态，真正执行线程体的代码块；
  • 阻塞状态：当调用 sleep，wait 或同步锁定时，线程进入阻塞状态，代码不再继续执行，阻塞事件解除之后，转到就绪状态等待调度；
  • 死亡状态：线程中断或者自然结束后，就会进入死亡状态，意味着它就不能再次启动。
    - 在这里插入图片描述

线程方法

线程方法有很多，主要用到的线程方法也就下面几种，以后碰到更多的方法继续补充：
在这里插入图片描述

停止线程

  • 不推荐使用jdk提供的stop()、destroy()方法（已废弃）；
  • 推荐：
  1. 一般设计者都会让线程自己停下来，不建议死循环下去；
  2. 使用一个标志位进行终止变量（当flag=false，则终止线程运行）
    设计一个标志位，比如：给 flag 一个 boolean 值，然后设置一个停止方法，把 boolean 值转换，在线程启动后通过判断语句判断到什么时候调用停止方法，flag 值变成 false while循环就会自动停止，这是比较简单的，复杂的线程停止也是这个思想；
public class TestStop implements Runnable{
    //设置一个标志位
    private boolean flag = true;

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

    //2.设置一个停止方法，转换标志位
    public void stop(){
        this.flag = false;
    }

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

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i==700){
                //转换标志位
                testStop.stop();
                System.out.println("子线程停止");
            }
        }
    }
}

线程休眠

  • sleep (时间)指定当前线程阻塞的毫秒数；
  • sleep 存在异常 InterruptedException ，要写一个异常处理；
  • sleep 时间达到后线程进入就绪状态；
  • sleep 可以模拟网络延时，倒计时等；
  • 每一个对象都有一个锁，sleep 不会释放锁。
  • 通过线程延迟发现程序错误！！！

使用 sleep 的例子：
模拟网络延迟

public class TestSleep implements Runnable{
    private int ticketNums = 10;
    @Override
    public void run() {
        while (true){
            if (ticketNums<=0){
                break;
            }
            //模拟延时，睡眠
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--拿到了第"+ticketNums--+"张票");
        }
    }

    public static void main(String[] args) {
        Test3 test3 = new Test3();
        new Thread(test3,"1号").start();
        new Thread(test3,"2号").start();
        new Thread(test3,"3号").start();

    }
}

模拟倒计时

public class TestSleep2 {

    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //模拟倒计时
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}

打印系统当前时间

public class TestSleep3 {

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

        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis());//更新获取的时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程礼让-Yield

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞；
  • 将线程从运行状态转为就绪状态；
  • 让cpu重新调度，礼让不一定成功！看CPU心情，结果是随机的。
//礼让线程测试
public class TestYield {

    public static void main(String[] args) {
        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()+"线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

在这里插入图片描述

线程强制执行_join

join强制执行其他子线程，等待子线程执行完，再执行其他线程，期间其他线程阻塞，需要抛出错误。

//join方法，类似与插队
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("vip线程——>"+i);
        }
    }


    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 500; i++) {
            if (i==200){
                thread.join();
            }
            System.out.println("main"+i);
        }
    }
}

Thread. State

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

  • NEW：尚未启动的线程处于此状态。
  • RUNNABLE：在Java虛拟机中执行的线程处于此状态。
  • BLOCKED：被阻塞等待监视器锁定的线程处于此状态。
  • WAITING：正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_ WAITING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED：已退出的线程处于此状态。

例子：观察线程的状态

public class TestState {
    public static void main(String[] args) {
        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);//NEW

        //启动线程并观察
        thread.start();
        state = thread.getState();
        System.out.println(state);//RUN

        while (state != Thread.State.TERMINATED){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = thread.getState();//更新状态
            System.out.println(state);
        }
    }
}

线程优先级

  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行；
  • 优先级的设定建议在start()调度前；
  • 线程的优先级用数字表示，范围从1~10；
    Thread.MIN_ PRIORITY = 1;
    Thread.MAX_ PRIORITY = 10;
    Thread.NORM_ PRIORITY = 5;
  • 使用以下方式改变或获取优先级，getPriority() 、setPriority(int xxx)
  • 优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了.这都是看CPU的调度。
//测试线程优先级
public class TestPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

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

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

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

        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();

        t5.setPriority(8);
        t5.start();

        t6.setPriority(7);
        t6.start();
    }
}

class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

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

守护线程（Daemon）

  • 线程分为用户线程和守护线程；
  • 虚拟机必须确保用户线程执行完毕；
  • 虚拟机不用等待守护线程执行完毕；
  • 守护线程作用：如，（gc()线程）后台记录操作日志，监控内存，垃圾回收等待…
小皮蛋^_^
关注
专栏目录
java多线程几种状态_java多线程的几种状态
weixin_39869593的博客
02-27 705
java线程状态在Thread中定义，源码中能看到有个枚举State，总共定义了六种状态：NEW： 新建状态，线程对象已经创建，但尚未启动RUNNABLE:就绪状态，可运行状态，调用了线程的start方法，已经在java虚拟机中执行，等待获取操作系统资源如CPU，操作系统调度运行。BLOCKED:堵塞状态。线程等待锁的状态，等待获取锁进入同步块/方法或调用wait后重新进入需要竞争锁WAITING...
Java多线程方法状态和创建（基础）
无极
09-02 268
Java之线程的五大状态及其常用方法（六个状态还有timed_wating超时等待） 1.线程的五大状态及其转换 线程的五大状态分别为：创建状态（New）、就绪状态（Runnable）、运行状态（Running）、阻塞状态（Blocked）、死亡状态（Dead）。 下面画出线程五大状态之间的关系图： （1）新建状态：即单纯地创建一个线程，创建线程有三种方式，在我的博客：线程的创建，可以自行查看！ （2）就绪状态：在创建了线程之后，调用Thread类的start()方法来启动一个线程，即表示线程进入就绪状态
Java多线程之线程状态
cao818的博客
09-26 101
目录 线程状态 线程方法 停止线程 线程休眠 线程礼让 Join线程合并 观测线程状态 线程状态 线程方法 setPriority(int newPriority) //更改线程的优先级 static void sleep(long millis) //在指定的毫秒数内让当前正在执行的线程休眠 void join() //等待该线程终止再执行其他线程 static void yield() //暂停当前正在执行的线程对象，并执行其他线程 void interrupt() //
初见Java多线程（三、线程的阻塞状态）
菜菜的博客
07-10 713
Java多线程的阻塞状态
WHUT-java多线程实验-第三周-文件上传和下载.zip
01-16
在“WHUT-java多线程实验-第三周-文件上传和下载.zip”这个实验中，我们将重点探讨如何在多线程环境中实现文件的上传和下载功能。这个实验基于IntelliJ IDEA开发环境，它是一个流行的Java集成开发环境，提供了丰富的...
深入分析JAVA 多线程--interrupt()和线程终止方式
08-19
JAVA 多线程 interrupt() 和线程终止方式 JAVA 多线程中，interrupt() 和线程终止方式是两个非常重要的概念。本文将深入分析 JAVA 多线程中 interrupt() 和线程终止方式的相关知识。 一、interrupt() 介绍 ...
java多线程--状态及方法
zhuzixi-的博客
06-26 213
1、线程五种状态 新建状态（new）：创建线程Thread对象进入新建状态。 就绪状态（runnable）：调用start()方法，线程会进入就绪状态，如果得到CPU资源就会进入运行状态。 运行状态（running） ：就绪状态得到 CPU 资源就会转为运行状态，执行 run() 方法，当调用 yield() 时线程会让步，从运行状态转到就绪状态，但该过程可能是及其短暂的，如果当前线程拥有较高优...
Java多线程-Thread类的常用结构及线程优先级
最新发布
01-27
Java多线程编程是开发高并发应用的基础，其中Thread类是实现多线程的核心类。本文将详细解析Thread类的常用结构以及线程优先级。 一、Thread类的常用结构 1. 线程中的构造器 - `Thread()`：创建一个没有指定名称...
Java多线程（3）--线程状态
lucien_ma的博客
06-01 197
线程状态 线程共有5中状态，在特定的情况下，线程可以在不同的转态之间切换 创建状态：实例化了一个新的线程对象，还未启动 就绪状态： 创建好的线程对象调用start()方法完成启动，进入线程池等待抢占CPU资源 运行状态： 线程对象获取了CPU资源，在一定的时间内执行任务 阻塞状态： 正在运行的贤臣暂停执行任务，释放所占用的CPU资源。并在解除阻塞状态只会也不能直接回到运行状态，而是重新回到就绪状态，等待获取CPU资源 终止状态： 线程运行完毕或因为异常导致该线程终止运行 Java多线程的知识持续
Java基础系列：多线程（二）阻塞状态与控制
古树清风的博客
10-09 223
Java多线程的阻塞状态与控制 上文已经提到Java阻塞的几种具体类型。下面分别看下引起Java线程阻塞的主要方法。 等待加入：join() join —— 让一个线程等待另一个线程完成才继续执行。如A线程线程执行体中调用B线程的join()方法，则A线程被阻塞，知道B线程执行完为止，A才能得以继续执行。 public class MyRunnable implements Runnable { ...
Java多线程中线程阻塞机制
Rocky实验室
03-22 2961
java 并发 同步
Java线程状态、线程停止、线程阻塞
吃果冻不吐果冻皮
05-28 5356
Java线程状态、线程停止、线程阻塞
Java 多线程的几种状态
weixin_46448719的博客
03-26 1567
Java中的线程的生命周期大体可分为5钟状态 新建(NEW): 新创建了一个线程对象。 可运行(RUNNABLE): 线程对象创建后，其他线程(比如main线程) 调用了该线程的 start() 方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取 cpu 的使用权。 运行中(RUNNING)： 可运行状态(runnable) 的线程获得了cpu 时间片，执行程序代码。 阻塞(BLOCKED): 阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了 cpu 时间片(timeslice)，
JAVA多线程04——线程状态、线程方法
weixin_44153521的博客
02-17 363
一、线程的五大状态 1、Thread t = new Thread() 线程对象一旦创建就进入到 了创建状态。 2、当调用start()方法，线程立即 进入就绪状态，但不意味着 立即调度执行。 3、就绪状态通过cpu调度进入运行状态，线程才真正 执行线程体的代码块。 4、当调用sleep，wait 或同步 锁定时，线程进入阻塞状态， 就是代码不往下执行，阻塞 事件解除后，重新进入就绪 状态，等待cpu调度执行。 5、线程中断或者结束，一旦进 入死亡状态，就不能再次启动。 二、线程方法
Java多线程--1--stop方法
qq_39611310的博客
06-21 2234
Java 多线程基础 – stop()方法 stop方法：强制停止一个正在运行的线程，无论此时线程是何种状态。 stop方法在停止线程时需要自行指定线程退出逻辑，否则线程会立即退出，不做任何清理操作，非常不安全，会造成数据不一致问题。 此处引用API的介绍 该方法具有固有的不安全性。用 Thread.stop 来终止线程将释放它已经锁定的所有监视器（作为沿堆栈向上传播的未检查 ThreadDeath 异常的一个自然后果）。 如果以前受这些监视器保护的任何对象都处于一种不一致的状态，则损坏的对象将对其他线程
Java多线程（二）：线程的常用方法和状态
澄白易的博客
04-19 1383
1.线程常用方法 1.1 线程终止 李四⼀旦进到工作状态，他就会按照行动指南上的步骤去进行工作，不完成是不会结束的。但有时我们需要增加⼀些机制，例如老板突然来电话了，说转账的对⽅是个骗子，需要赶紧停止转账，那张三该如何通知李四停止呢？这就涉及到我们的停止线程的方式了。 目前常见的有以下两种方式： 通过 自定义标记符 来进行中断。 调用interrupt() 方法来中断。 1.1.1 自定义标记符 // 1.先声明一个标识符 private volatile static b..
线程池的状态、submit（）和execute（）方法的区别
weixin_43946462的博客
06-17 616
一、线程池的结构 1、线程池管理器（ThreadPoolManager）:用于创建并管理线程池 2、工作线程（WorkThread）: 线程池中线程 3、任务接口（Task）:每个任务必须实现的接口，以供工作线程调度任务的执行。 4、任务队列:用于存放没有处理的任务。提供一种缓冲机制。 二、线程池的5种状态 Running、ShutDown、Stop、Tidying、Terminated。 线程池各个状态切换框架图： RUNNING：线程池的初始化状态，接受新的任务，处理等待队列中的任务。线程池被一旦被创
java线程的五大状态，阻塞状态详解
热门推荐
LifeGoesOn
08-17 1万+
一、状态简介 一个线程的生命周期里有五大状态，分别是： 新生 就绪 运行 死亡 运行后可能遇到的阻塞状态 二、相关方法 2.1 新生状态 Thread t = new Thread(); 正如我们前面所说的，一个线程开始之后有自己的内存空间，这些工作空间和主内存进行交互，从主内存拷贝数据到工作空间。 当这个语句执行的时候，线程创建，开辟工作空间，也就是线程进入了新生状态。 2.2 就绪状态 普通情况，一旦调用了： t.start(); start 方法被调用，线程立即进入了就绪状态，表示这个线程具
Java线程唤醒与阻塞
hugh 的博客
03-17 1108
阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。　　1. sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间 内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。 　　典型地，sleep() 被用在等待某个资
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值