Java线程中的状态

• NEW(创建状态):安排了工作`,还未开始行动,即Thread对象创建好了,但是还没有调用start方法.

Thread t = new Thread(() -> {
       // 线程执行的代码
   });
   System.out.println(t.getState());
   t.start();

• RUNNABLE(就绪状态): 可工作的. 又可以分成正在工作中和即将开始工作,1.线程正在cpu上运行 2.线程在排队等待,随时可以去cpu上运行.

Thread t = new Thread(() -> {
       while (true) {
           // 可运行状态下的代码
       }
   });
   t.start();
   System.out.println(t.getState());

• BLOCKED(阻塞状态): 因为synchronized锁产生阻塞,表示等待获取监视器锁,因为其他线程正在持有该锁

public static void main(String[] args) {  
    Object lock = new Object();  
    Thread thread1 = new Thread(() -> {  
        synchronized (lock) {  
            try {  
                Thread.sleep(1000); // 等待一段时间，让线程2有机会尝试获取锁  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            // 获取lock锁并执行操作  
        }  
    });  
      
    Thread thread2 = new Thread(() -> {  
        synchronized (lock) {  
            // 获取lock锁并执行操作  
        }  
    });  
      
    thread1.start();  
    thread2.start();  
      
    try {  
        thread1.join(); // 等待线程1结束  
    } catch (InterruptedException e) {  
        e.printStackTrace();  
    }  
    try {  
        thread2.join(); // 等待线程2结束  
    } catch (InterruptedException e) {  
        e.printStackTrace();  
    }  
      
    System.out.println(thread1.getState());  
    System.out.println(thread2.getState());  
}

• WAITING(阻塞状态): 因为调用了wait产生阻塞,表示无期限的等待另一个线程执行特定的操作(如等待通知)

public static void main(String[] args) {
        Object monitor = new Object();
        Thread t = new Thread(() -> {
            synchronized (monitor) {
                try {
                    monitor.wait(); // 等待通知或中断
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        try {
            Thread.sleep(1000); // 等待一段时间，确保线程进入等待状态
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(t.getState());
    }

• TIMED_WAITING(阻塞状态): 因为sleep产生阻塞,表示线程等待另一个线程执行特定操作,但最多等待一段时间.

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(5000); // 等待1秒钟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
        Thread.sleep(1000);
        System.out.println(t.getState());
    }

• TERMINATED: 工作完成了.线程已经结束,但是Thread对象还在.

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            // 执行完任务
        });
        t.start();
        // 等待线程执行完成
        t.join();
        System.out.println(t.getState());
    }

线程的状态转移至少具备5种:创建状态,运行状态,就绪状态,阻塞状态,结束状态.

当Java线程在不同的状态之间转移时,会受到不同的条件和操作影响,关于线程状态之间切换的详细解释:
1.NEW(新建) -> RUNNABLE(运行状态):通过调用线程对象的start()方法启动线程,pcb会为线程分配资源,将其标记为可运行状态.
2. RUNNABLE(运行状态) -> BLOCKED(阻塞状态):当线程进入由其他线程持有的监视器锁的同步块时,如果锁不可用,该线程将会被阻塞,线程就会进入BLOKED(阻塞)的状态,直到它获得所需要的锁.
3. RUNNABLE(运行) -> WAITING(阻塞):调用了Object.wait()方法,使线程进入无限期等待的状态.线程会在等待队列中,直到另一个线程调用notify()或者notifyAll()方法将其唤醒线程.
4. RUNNABLE(运行) -> TIMED_WAITING(阻塞):线程调用了超时参数Thread.sleep(),Object.wait(long),Thread.join(long)等方法.线程会等待一段指定的时间,超时后就会重新变为可运行的状态.
5. BLOCKED(阻塞) -> RUNNABLE(运行):线程的持有的监视器锁变得可用.线程会从阻塞状态转移到可运行状态,继续执行
6. WAITING(阻塞) -> RUNNABLE(运行):其他线程调用了等待线程所在对象的notify()或notifyAll()方法或者线程等待的时间到达,或者线程被中断,都会是等待线程进入可运行状态.
7. TIMED_WAITING(阻塞) -> RUNNABLE(运行):超时时间到达,线程等待的时间到达后,线程会从阻塞状态下转移到可运行的状态
8. RUNNABLE(运行) -> TERMINATED(终止):线程的run()方法执行完成或者线程因异常而提前退出,线程进入终止状态,不再继续执行.