Java并发之线程状态

最新推荐文章于 2020-10-26 00:13:54 发布
最新推荐文章于 2020-10-26 00:13:54 发布
阅读量124 收藏
点赞数
分类专栏： Java并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YJ_GuiGuZi/article/details/107794230
版权

线程状态

在这里插入图片描述

新建状态(NEW)

    使用 new 操作符创建一个线程，并且尚未调用 start() 方法，此时线程处在新建状态。

Thread t = new DemoThread();
System.out.println(t.getState());
// output: NEW

可运行状态/就绪状态(RUNNABLE)

    一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的 start() 方法。当线程对象调用 start() 方法即启动了线程，start() 方法创建线程运行的系统资源，并调度线程运行 run() 方法。当start()方法返回后，线程就处于就绪状态。
    处于就绪状态的线程并不一定立即运行 run() 方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。

Thread t = new DemoThread();
t.start(); // 启动线程
System.out.println(t.getState());
// output: RUNNABLE

阻塞状态(BLOCKED)

    线程处于阻塞状态时，该线程还没有运行结束，只是暂时让出CPU，让其他处于就绪状态的线程有机会获得CPU使用时间，进入运行状态。

synchronized

    比较经典的就是synchronized关键字，这个关键字修饰的代码块或者方法，均需要获取到对应的锁，在未获取之前，其线程的状态处于BLOCKED，如果线程长时间处于这种状态下，就需要看是否出现死锁的问题。

public class MyThread extends Thread{

    private byte[] lock = new byte[0];

    public MyThread(byte[] lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock){
            try {
                System.out.println(Thread.currentThread().getName() + " is running.");
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " done.");

        }
    }

    public static void main(String[] args) throws InterruptedException {
        byte[] lock = new byte[0];
        MyThread thread1 = new MyThread(lock);
        thread1.setName("thread1");
        thread1.start();
        MyThread thread2 = new MyThread(lock);
        thread2.setName("thread2");
        thread2.start();
        Thread.sleep(1000);//等一会再检查状态
        System.out.println("thread2 当前状态" + thread2.getState());
    }
    /* output:
     * thread1 is running.
     * thread2 当前状态BLOCKED
     * thread1 done.
     * thread2 is running.
     * thread2 done.
     */
}

等待状态

当执行如下代码的时候，对应的线程会进入到 WAITING 状态

  • Object.wait()
  • Thread.join()
  • LockSupport.park()

Object.wait()

public class MyThread extends Thread{
    private Object lock;

    public MyThread(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        System.out.println("等待进入 synchronized 方法");
        synchronized (lock){
            try {
                System.out.println("调用 wait() 方法，释放锁");
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        byte[] lock = new byte[0];
        MyThread myThread = new MyThread(lock);
        myThread.setName("myThread");
        myThread.start();
        Thread.sleep(100);
        System.out.println("myThread 当前状态 " + myThread.getState());
        synchronized (lock){
            lock.notify(); //notify通知wait的线程
        }
        Thread.sleep(100);
        System.out.println("myThread 当前状态 " + myThread.getState());
    }
    /*
     * 等待进入 synchronized 方法
     * 调用 wait() 方法，释放锁
     * myThread 当前状态 WAITING
     * myThread 当前状态 TERMINATED
     */
}

Thread.join()

public class MyThread extends Thread{
    private Object lock;

    public MyThread(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        System.out.println("thread1 正在执行。");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("thread1 执行完毕。");
    }
}

public class MyOtherThread extends Thread{
    Thread thread;

    public MyOtherThread(Thread thread) {
        this.thread = thread;
    }

    @Override
    public void run() {
        System.out.println("thread2 正在执行。并调用 thread1 的 join() 方法");
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("thread1 执行完毕，thread2 后续代码开始执行。");
        System.out.println("thread2 后续代码执行完毕。");
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        byte[] lock = new byte[0];
        MyThread thread1 = new MyThread(lock);
        thread1.start();
        MyOtherThread thread2 = new MyOtherThread(thread1);
        thread2.start();
        Thread.sleep(100);
        System.out.println("thread2当前状态为 " + thread2.getState());
    }
    /** output:
     * thread1 正在执行。
     * thread2 正在执行。并调用 thread1 的 join() 方法
     * thread2当前状态为 WAITING
     * thread1 执行完毕。
     * thread1 执行完毕，thread2 后续代码开始执行。
     * thread2 后续代码执行完毕。
     */
}

LockSupport.park()

import java.util.concurrent.locks.LockSupport;

public class MyThread extends Thread{
    private Object lock;

    public MyThread(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        System.out.println("调用 LockSupport.park()");
        LockSupport.park();
    }

    public static void main(String[] args) throws InterruptedException {
        byte[] lock = new byte[0];
        MyThread thread = new MyThread(lock);
        thread.start();
        Thread.sleep(100);
        System.out.println("thread 当前状态为 " + thread.getState());
        System.out.println("调用 LockSupport.unpark(thread)");
        LockSupport.unpark(thread);
        Thread.sleep(100);
        System.out.println("thread 当前状态为 " + thread.getState());
    }
    /**output:
     * 调用 LockSupport.park()
     * thread 当前状态为 WAITING
     * 调用 LockSupport.unpark(thread)
     * thread 当前状态为 TERMINATED
     */
}

计时等待状态(TIMED_WAITING)

    TIMED_WAITING 和 WAITING 状态的区别在于，TIMED_WAITING 的等待是有一定时效的，而 WAITING 状态等待的时间是永久的，必须等到某个条件符合才能继续往下走，否则线程不会被唤醒。
    而 TIMED_WAITING，等待一段时间之后，会唤醒线程去重新获取锁。

当执行如下代码的时候，对应的线程会进入到 TIMED_WAITING 状态

  • Thread.sleep(long)
  • Object.wait(long)
  • Thread.join(long)
  • LockSupport.parkNanos()
  • LockSupport.parkUntil()

Thread.sleep(long)

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 调用 sleep(10000) 方法");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " sleep(10000) 方法执行完毕");
    }
    public static void main(String[] args) throws InterruptedException {
        byte[] lock = new byte[0];
        MyThread myThread = new MyThread();
        myThread.setName("myThread");
        myThread.start();
        Thread.sleep(1000);//等一会再检查状态
        System.out.println("myThread 当前状态" + myThread.getState());
    }
    /* output:
     * myThread 调用 sleep(10000) 方法
     * myThread 当前状态TIMED_WAITING
     * myThread sleep(10000) 方法执行完毕
     */
}

Object.wait(long)

public class MyThread extends Thread{
    private Object lock;

    public MyThread(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        System.out.println("获取锁");
        synchronized (lock){
            try {
                System.out.println("调用 wait(1000) 方法，释放锁");
                lock.wait(1000);//注意，此处1s之后线程醒来，会重新尝试去获取锁，如果拿不到，后面的代码也不执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("开始执行 wait() 后续代码");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("后续代码执行完毕");
        }
    }
    public static void main(String[] args) throws InterruptedException {
        byte[] lock = new byte[0];
        MyThread myThread = new MyThread(lock);
        myThread.setName("myThread");
        myThread.start();
        Thread.sleep(100);
        System.out.println("myThread 当前状态 " + myThread.getState());
        Thread.sleep(2000);//等一会再检查状态
        System.out.println("myThread 当前状态 " + myThread.getState());
    }
    /*
     * 获取锁
     * 调用 wait(1000) 方法，释放锁
     * myThread 当前状态 TIMED_WAITING
     * 开始执行 wait() 后续代码
     * 后续代码执行完毕
     * myThread 当前状态 TERMINATED
     */
}

终止状态(TERMINATED)

  • run() 方法运行结束
  • 出现未捕获异常导致 run() 方法异常终止
YJ_GuiGuZi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程之并发工具类
12-22
Semaphore可以用于限制系统中的并发线程数，防止过多的线程同时访问有限的资源，从而避免资源耗尽。 在实际编程中，这三种工具类可以根据需求灵活选择。例如，CountDownLatch适合于一次性事件，如等待一组线程完成...
[Java并发编程]-线程的六种状态及其状态转换
UniKylin
04-15 7321
1.线程自身信息线程运行的过程会产生很多信息，这些信息都保存在Thread类中的成员变量里面，常见的有： a.线程的ID是唯一标识getId() b.线程的名称：getName()，如果不设置线程名称默认为“Thread-xx” c.线程的优先级：getPriority，线程优先级从1-10,其中数字越大表示优先级别越高，同时获得JVM调度执行的可能性越大，JDK内置了三种常见的状态：//最小
Java高并发之设计模式.
weixin_30390075的博客
06-11 149
本文主要讲解几种常见并行模式, 具体目录结构如下图. 单例 单例是最常见的一种设计模式, 一般用于全局对象管理, 比如xml配置读写之类的. 一般分为懒汉式, 饿汉式. 懒汉式: 方法上加synchronized 1 public static synchronized Singleton getInstance() { 2 if (single == ...
Java并发 浅谈线程状态
王员外的博客
10-26 301
0、Thread下有个静态的内部枚举类，就叫做State，里面定义了线程的状态。ps：我也不知道网上那些其他的状态是从哪里来的，简直就是坑爹呀…… /** * A thread state. A thread can be in one of the following states: * 一个线程状态。 一个线程可以是下面状态中的其中一个 * <li...
Java并发_线程的五种状态
田磊的博客
04-29 196
Java并发_线程的五种状态新建状态（new Thread(),并没执行start方法）就绪状态（执行了start方法，等待分配cpu）运行状态(执行run方法)阻塞状态（sleep/wait/竞争锁/挂起）死亡状态 新建状态（new Thread(),并没执行start方法） 当用new操作符创建一个线程时， 例如new Thread®，线程还没有开始运行，此时线程处在新建状态。 当一个线程...
Java并发编程（一）线程定义、状态和属性
热门推荐
Android进阶三部曲 - 刘望舒
10-05 1万+
一 、线程和进程 1. 什么是线程和进程的区别: 线程是指程序在执行过程中，能够执行程序代码的一个执行单元。在java语言中，线程有四种状态：运行 、就绪、挂起和结束。 进程是指一段正在执行的程序。而线程有事也被成为轻量级的进程，他得程序执行的最小单元，一个进程可以拥有多个线程，各个线程之间共享程序的内功空间（代码段、数据段和堆空间）及一些进程级的资源（例如打开的文件），但是各个线程都拥
Java并发编程线程间通讯实现过程详解
08-19
"Java并发编程线程间通讯实现过程详解" Java并发编程线程间通讯实现过程详解是Java编程中非常重要的一部分，涉及到多线程之间的数据共享、同步和通信。在Java中，线程间通讯可以通过多种方式实现，本文将通过示例...
Java多线程 线程状态原理详解
08-25
Java多线程是并发编程中的核心概念，它允许程序同时执行多个任务，从而提升系统效率。线程状态的理解对于编写高效、稳定的并发程序至关重要。...熟练掌握这些知识能帮助开发者编写出更加健壮和高效的Java并发程序。
java并发编程：线程基础
08-09
Java并发编程中的线程基础是理解多线程编程的关键，它涵盖了从线程的创建到管理，再到线程间通信的全过程。多线程编程在处理高性能和高响应性的应用程序时至关重要，因为它允许程序在单个进程中同时执行多个任务，...
Java并发编程进程和线程之由来Java开发Java经验技
11-22
Java并发编程是Java开发中的重要领域，涉及到进程与线程的概念，这两个概念是理解多任务执行的基础。在现代计算机系统中，进程和线程被广泛用于实现高效的资源管理和任务调度。 **1. 进程** 进程是操作系统分配...
Java并发-线程的状态
Dave的博客
07-11 153
线程的状态 线程状态变迁 Java将操作系统中的运行和就绪两个状态合并称为运行状态。
光纤振动传感器的研究.doc
07-16
传感器
光纤位移传感器实验.doc
07-16
传感器
传感器原理课程实践.doc
07-16
传感器
2018年度产成品出入库单excel模板
07-16
【作品名称】：2018年度产成品出入库单excel模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
西藏民族大学考研，45个专业课历年考试真题及答案汇总，备考资料题库笔记，专业课调剂信息查询.pdf
07-16
西藏民族大学考研，45个专业课历年考试真题及答案汇总，备考资料题库笔记，专业课调剂信息查询.pdf
材料出库汇总表Excel模板
07-16
【作品名称】：材料出库汇总表Excel模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
高校学生管理系统的设计与实现-开题报告.doc
最新发布
07-16
高校学生管理系统的设计与实现-开题报告.doc
Java 多线程与并发(2-26)Java 并发 - 线程基础.pdf
07-14
1. **线程状态转换** Java线程共有五种状态：新建（New）、可运行（Runnable）、阻塞（Blocking）、无限期等待（Waiting）和限期等待（TimedWaiting），以及死亡（Terminated）。 - 新建状态：线程被创建但未启动...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值