java并发编程笔记：线程的状态

最新推荐文章于 2025-08-05 17:34:52 发布

上校狙击手

最新推荐文章于 2025-08-05 17:34:52 发布

阅读量88

点赞数 1

文章标签： java 笔记开发语言

java线程在运行的声明周期会有6种不同的状态，在给定的一个时刻，线程只能处于其中的一个状态。

java并发编程笔记：线程的状态_等待状态

注意：java将操作系统中的运行和就绪两个状态合并称为运行状态。

阻塞状态是进入Synchronized关键字修饰的方法或代码块获取锁的状态。

java并发编程笔记：线程的状态_jvm_02

（1）线程创建后，调用start方法开始运行。

（2）线程执行wait方法，进入等待状态。

a.进入等待状态的线程需要依靠其他线程的通知才能返回运行状态

b.超时状态相当于在等待状态的基础上增加了超时限制,超时时间到达会自动返回运行状态。

（3）当线程调用同步方法时，在没有获取到锁的情况下，线程会进入阻塞状态

（4）线程在执行完Runnable的run方法后会进入到终止状态

测试代码：

public class 线程状态 {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
       new Thread(new TimeWaiting(),"TimeWaitingThread").start();
       new Thread(new Waiting(),"WaitingThread").start();
       //使用两个blocke线程，一个获取锁成功，另一个被阻塞
       new Thread(new Blocked(),"BlockedThread-1").start();
       new Thread(new Blocked(),"BlockedThread-2").start();
    }
    //该线程不断进行睡眠
    static class TimeWaiting implements Runnable{

        @Override
        public void run() {
            while(true){
                SleepUtils.second(100);
            }
        }
    }
    //该线程在Waiting.class实例上等待
    static class Waiting implements Runnable{

        @Override
        public void run() {
            while(true){
                synchronized (Waiting.class){
                    try {
                        Waiting.class.wait();
                        /*
                   * Causes the current thread to wait until another thread invokes the notify() method or
                   * the notifyAll() method for this object.
                   * In other words, this method behaves exactly as if it simply performs the call wait(0).
                   * The current thread must own this object's monitor.
                   * The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method.
                   * The thread then waits until it can re-obtain ownership of the monitor and resumes execution.
                   * As in the one argument version, interrupts and spurious wakeups are possible,
                   * and this method should always be used in a loop:
                        synchronized (obj) {
                           while (<condition does not hold>)
                                     obj.wait();
               ... // Perform action appropriate to condition
           }
       */
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    //该线程在Blocked.class实例上加锁后,不会释放该锁。
    static class Blocked implements Runnable{
        @Override
        public void run(){
            synchronized (Blocked.class){
                while(true){
                    SleepUtils.second(100);
                }
            }
        }
    }
}
class SleepUtils{
    public static  final void second(long seconds){
        try {
            TimeUnit.SECONDS.sleep(seconds);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

原创作者: u_16969274 转载于: https://blog.51cto.com/u_16969274/11821251