线程的全生命周期（5种状态）及wait()、 notify()以及notifyAll() 和多线程插队join

最新推荐文章于 2022-08-06 00:55:20 发布

我和ye猫子

最新推荐文章于 2022-08-06 00:55:20 发布

阅读量364

点赞数

分类专栏：多线程

本文链接：https://blog.csdn.net/u011441473/article/details/117674613

版权

多线程专栏收录该内容

8 篇文章 0 订阅

订阅专栏

线程声明周期

Java中的线程的生命周期大体可分为5种状态。

1. 新建(NEW)：

新创建了一个线程对象。

2. 可运行(RUNNABLE)：

线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权。

3. 运行(RUNNING)：

可运行状态(runnable)的线程获得了cpu 时间片（timeslice），执行程序代码。

4. 阻塞(BLOCKED)：

阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种：
(一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
(二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
(三). 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

5. 死亡(DEAD)：

线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

wait()、 notify()以及notifyAll()的使用

调用wait()、 notify()以及notifyAll()时需要注意的细节，如下。
1）使用wait()、notify()和notifyAll()时需要先对调用对象加锁。
2）调用wait()方法后，线程状态由 RUNNING变为WAITING，并将当前线程放置到对象的
等待队列。
3） notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或
notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。
4） notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()
方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由 WAITING变为
BLOCKED。
5）从wait()方法返回的前提是获得了调用对象的锁。

要注意的一点就是执行notifyAll()方法时不会立刻就释放对象的锁，而是要等到线程执行完成后才会释放

但是执行wait()方法时就是会立刻释放对象的锁，然后当前线程就会卡在wait()方法处，等待唤醒

另外还有一点需要提的是这三个方法都必须被包裹在同步块中！

例子：

package com.jokin.learn.Thread;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadPool3 {

    public static void main (String[] args){
        Object ob = new Object();
        ExecutorService  es =Executors.newFixedThreadPool(2);
        //调用Callable<T> task 实现多线程，Callable实现了，线程返回一个返回值（带类型）
        Future<Long> future =null;
        future  = es.submit(()->{
            synchronized(ob){
                System.out.println("先执行的线程"+Thread.currentThread().getId());
                ob.wait(10000);
                System.out.println( "虽然先执行但是 wait 后执行继续往下执行吗");
                return Thread.currentThread().getId();
            }

        });


        es.submit(()->{
            synchronized(ob){
                System.out.println("后执行的线程"+Thread.currentThread().getId());
                //ob.wait(10000);
                System.out.println( "wait22222 后执行继续往下执行吗");
                //return Thread.currentThread().getId();
            }

        });
        // future.get()是一个阻塞方法。阻塞到Callable 方法返回值之后输出
        try {
           System.out.println( "阻塞返回值"+future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }

}

结果：