Java中6种线程状态详解

最新推荐文章于 2023-07-05 13:59:32 发布
最新推荐文章于 2023-07-05 13:59:32 发布
阅读量465 收藏 1
点赞数
分类专栏： java 文章标签： java thread 线程 线程状态 阻塞
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23091073/article/details/89889913
版权

JAVA中6种线程状态

位于java.lang.Thread类中有个内部枚举State，定义了Java中6种线程状态，可以通过使用Thread的getState()获取线程状态

public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
}

线程转化图

1. NEW

创建后尚未启动的线程处于这个状态

public class NewThread extends Thread{
    @Override
    public void run() {
        System.out.println("NewThread run");
    }
}

public class Main {
    public static void main(String[] args) {
		NewThread thread = new NewThread();
		System.out.println(thread.getState());
	}
}

2. RUNNABLE

处于此状态的线程可能正在运行(running)，也可能正在等待系统资源(ready)

public class NewThread extends Thread{
    @Override
    public void run() {
        System.out.println("NewThread run");
    }
}

public class Main {
    public static void main(String[] args) {
		ExtendClass thread = new ExtendClass();
		thread.start();
		System.out.println(thread.getState());
	}
}

3. BLOCKED

阻塞状态，当一个线程要进入synchronized语句块/方法时，如果没有获取到锁，会变成BLOCKED,或者在调用Object.wait()后，被notify()唤醒，再次进入synchronized语句块/方法时，如果没有获取到锁，会变成BLOCKED

3.1 第一种情况:enter 同步块阻塞

thread1和thread2，先让thread1占用BlockThread.block()，由于block()执行需要10s，thread2在1s后start，由于同步，没有进入block()，被堵塞住，此时输出状态为BLOCKED

public class Block {
    public static synchronized void block(){
        try {
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
		Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                Block.block();
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                Block.block();
            }
        });
        thread1.start();
		try {
            Thread.sleep(1000);// 保证thread1运行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
        try {
            Thread.sleep(1000);// 保证thread2运行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread2.getState());
	}
}

3.2 第二种情况: wait后reenter同步块阻塞

thread1和thread2得到lock对象锁后都调用了wait方法，释放掉了。接着thread3得到lock对象锁后调用notifyAll后，thread1和thread2开始抢占lock，其中有一个抢到，另一个就处于阻塞状态

public class Main {
    public static void main(String[] args) {
		Object lock = new Object();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        System.out.println("thread1准备wait等待，释放lock");
                        lock.wait();
                        Thread.sleep(1000);
                        System.out.println("thread1拿到lock，继续下一步");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        System.out.println("thread2准备wait等待，释放lock");
                        lock.wait();
                        Thread.sleep(1000);
                        System.out.println("thread2拿到lock，继续下一步");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("thread3拿到lock，准备notify");
                    lock.notifyAll();
                    System.out.println("thread3释放lock");
                }
                System.out.println("thread1状态:"+thread1.getState());
                System.out.println("thread2状态:"+thread2.getState());
            }
        });

        thread1.start();
        thread2.start();
        try {
            Thread.sleep(500);// 保证thread1 thread2运行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread3.start();
	}
}

4. WAITING

线程陷入无限期等待状态，使用以下三个方法会让线程处于这种状态

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

4.1 wait()

thread1进入同步代码块,获取到lock的对象锁，但是调用了lock的wait()方法，释放掉了对象锁，此时进入waiting状态，同时thread2执行，获取到lock的对象锁，调用lock的notify()方法，唤醒等待线程中任意一个，由于就1个，所以唤醒thread1

public class Main{
	public static void main(String[] args) {
		Object lock = new Object();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        System.out.println("thread1准备wait等待，释放lock");
                        lock.wait();
                        System.out.println("thread1拿到lock，继续下一步");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread1.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread1.getState());

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("thread2拿到lock，准备notify");
                    lock.notify();
                    System.out.println("thread2释放lock");
                }
            }
        });
        thread2.start();
    }
}

4.2 join()

public class Main{
	public static void main(String[] args) {
		Thread parent = new Thread( () -> {
            Thread son = new Thread(() -> {
                System.out.println("子线程执行");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            son.start();
            try {
                son.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        parent.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(parent.getState());
	}
}

4.3 park()

public class Main{
	public static void main(String[] args) {
		Thread thread1 = new Thread(() -> {
            System.out.println("park执行前");
            LockSupport.park();
            System.out.println("park执行后");
        });
        thread1.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread1.getState());
        LockSupport.unpark(thread1);
        System.out.println("执行unpack");
	}
}

5. TIMED_WAITING

限期等待状态,在一定时间之后会由系统自动唤醒

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

5.1 sleep()

public class Main{
	public static void main(String[] args) {
		Thread thread1 = new Thread(() -> {
            try {
                Thread.sleep(2 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread1.start();
        System.out.println(thread1.getState());
	}
}

5.2 wait(timeout)

public class Main{
	public static void main(String[] args) {
		Object lock = new Object();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        System.out.println("thread1准备wait等待，释放lock");
                        lock.wait(1000);
                        System.out.println("thread1拿到lock，继续下一步");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread1.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread1.getState());

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("thread2拿到lock，准备notify");
                    lock.notify();
                    System.out.println("thread2释放lock");
                }
            }
        });
        thread2.start();
	}
}

5.3 join(timeout)

public class Main{
	public static void main(String[] args) {
		Thread parent = new Thread( () -> {
            Thread son = new Thread(() -> {
                System.out.println("子线程执行");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            son.start();
            try {
                son.join(10 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        parent.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(parent.getState());
	}
}

5.4 parkNanos()

public class Main{
	public static void main(String[] args) {
		Thread thread1 = new Thread(() -> {
            System.out.println("parkNanos执行前");
            LockSupport.parkNanos(1000 *1000 * 1000);
            System.out.println("parkNanos执行后");
        });
        thread1.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread1.getState());
        LockSupport.unpark(thread1);
        System.out.println("执行unpack");
	}
}

5.5 parkUntil()

public class Main{
	public static void main(String[] args) {
		Thread thread1 = new Thread(() -> {
            System.out.println("parkUntil执行前");
            LockSupport.parkUntil(System.currentTimeMillis() + 1000);
            System.out.println("parkUntil执行后");
        });
        thread1.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread1.getState());
        LockSupport.unpark(thread1);
        System.out.println("执行unpack");
	}
}

6. TERMINATED

终止状态，处于此状态的线程执行完run方法

public class Main {
    public static void main(String[] args) {
		Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
            }
        });
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread.getState());
	}
}
aabond
关注
专栏目录
Java线程的6种状态及切换(透彻讲解)
共同进步，共同学习。
06-27 281
我们先来看看操作系统中的线程状态转换。在操作系统中，线程被视为轻量级的进程，所以。​系统进程/线程转换图。
Java 线程的6种状态（简单介绍）
爱你の大表哥的博客
08-15 5695
关于Java线程的状态网上的说法不一，有的说是6种状态，有的说是5中状态，索性就查看了一下Java源码。Thread类里面有一个枚举类，如下： public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; } 这个枚举类里面有6种类型，所以Java中...
java线程状态详解
慕柏的博客
11-18 330
线程状态 线程状态总共可分为五大状态： 新建 可运行 运行 等待阻塞睡眠 死亡，如下图所述： 1.新建（NEW）： 线程对象已经创建，但还没调用start()方法。 2.可运行（RUNNABLE）： 当线程有资格运行，但还没有获得cpu资源。当start()方法调用后，线程先处于可运行状态；当线程运行后或者从等待/阻塞/睡眠回来也可以进入可运行状态。 3.运行（RUNNING）： 当一...
Java 线程状态详解
m0_63904107的博客
07-05 894
Java线程状态详解(New,Terminated,Runnable,Blocked,Waiting等)
Java线程状态详解
weixin_34452850的博客
02-26 435
Java线程状态详解 一. 背景 最近在深入研究Java并发编程，看到网上有很多关于线程状态的总结，有的不全面，有的根本就是错的。因此，在这里我结合最权威的Java源代码，尝试对Java线程状态进行一个详细的解读。 二. 线程状态定义 Java线程状态使用Thread的内部类State来表示，而在Thread类中，也有一个threadStatus字段来标明当前线程的状态。Java通过一个nativ...
基于java 线程的几种状态(详解)
08-29
基于Java线程的几种状态详解 Java线程的状态是一个复杂的概念，它们之间的转换关系也非常重要。下面我们将详细解释Java线程的六种状态：New、Runnable、Blocked、Waiting、Timed waiting和Terminated。 1. 新创建...
Java多线程 线程状态原理详解
08-25
在Java中，`java.lang.Thread.State`枚举类定义了线程的六种状态，分别是： 1. **NEW**：新建状态，线程被创建但尚未调用`start()`方法。 2. **RUNNABLE**：运行状态，线程可能正在执行，也可能在等待CPU调度。 3. ...
java多线程中线程封闭详解
08-25
Java多线程中，线程封闭是一种重要的并发控制策略，其核心思想是限制共享数据的访问，从而避免因多线程并发导致的数据不一致问题。本文将深入探讨线程封闭的概念、实现方式及其应用场景。 线程封闭的概念在于，确保...
Java多线程详解及示例
最新发布
07-20
守护线程（Daemon Thread）是一种特殊线程，当所有非守护线程结束时，守护线程也会随之结束，通常用于后台服务。 总结： Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步...
java 线程详解及线程与进程的区别
08-31
Java线程详解与进程的区别是理解多任务并发执行的关键。在计算机系统中，进程和线程是两种不同的执行单元。 1. **进程**：每个进程都有独立的内存空间，这意味着不同进程之间的数据不能直接共享。例如，当你打开多...
java线程的6种状态分析
AsapDawn的博客
04-14 271
一、哪六种？ NEW RUNNABLE BLOCKED WAITING TIMED_WAITING TERMINATED 二、官方源码怎么说？ 我们可以看到官方源码中对于线程的状态，使用了一个枚举类。在枚举类中定义了一个java线程所拥有的六种状态分别是什么，并且给出了简洁的解释以及一些线程转换相关的方法。请仔细阅读下面的代码片段。 public enum State { ...
Java线程的6种状态分析
weixin_44980618的博客
03-18 89
https://www.jianshu.com/p/ec94ed32895f
详细讲讲Java线程的状态
liuruiaaa的博客
04-11 993
详细讲讲Java线程的状态
java 中线程的状态有哪些？
stone_tomcate的博客
09-18 173
用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态： 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件 运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能 阻塞：在...
Java中线程的状态有哪些
as953的博客
03-02 155
线程状态： 创建状态，就绪状态，运行状态，阻塞状态，死亡状态 创建状态：     在程序中用构造函数方法创建了一个线程对象后，新的线程对象就处于创建状态，此时，它已经获取了相应的资源，但还没有处于可运行状态，这时Thread类的方法来设置线程对象的属性如设置线程名(setName()),设置线程优先级(setPriority())等。 就绪状态：     线程创建后，就可以通过调用start()方法启动线程，即进入就
Java 中的线程有几种状态？
weixin_41163113的博客
01-17 221
线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。 1、新建状态（New）：当 new 出一个线程对象来时，线程就进入了新建状态。 2、就绪状态（Runnable）：当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。 3、运行状态（R...
Java中的线程有几种状态
weixin_42258272的博客
12-20 176
1、创建状态（new）：新建了一个线程对象 2、就绪状态（Runnable）：创建线程对象后，其他线程调用了该对象的start（）方法，此线程位于可运行池中，等待cpu的使用权 3、运行状态（Running）：得到CPU时间片 4、阻塞状态（Blocked）：线程因某种原因暂时放弃CPU的使用权，暂时停止运行，直到线程进入就绪状态，才有机会转入运行状态 1）同步阻塞：运行的线程在获取对象的同步锁时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

aabond

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值