多线程运行状态，sleep(),wait(),yield(),join()的理解

最新推荐文章于 2025-07-29 16:21:00 发布

原创最新推荐文章于 2025-07-29 16:21:00 发布 · 2k 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#sleep和wait的区别 #yield #join #线程运行状态

多线程专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了Java中线程的生命周期状态，包括新建、就绪、运行、阻塞和死亡状态，并解释了sleep()、wait()、yield()和join()等线程控制方法的工作原理与使用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

开始前，先看下线程的运行状态。

线程生命周期

一个线程从创建到死亡，经历了哪些状态呢

创建（new）状态: 准备好了一个多线程的对象
就绪/可运行（runnable）状态: 调用了start()方法, 等待CPU进行调度
运行（running）状态: 执行run()方法
阻塞（blocked）状态: 暂时停止执行, 可能将资源交给其它线程使用
死亡（dead）状态: 线程销毁

1、新建( new )：新创建了一个线程对象。

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

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

4、阻塞( block )：阻塞状态是指线程因为某种原因放弃了 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 ()方法，则该线程结束生命周期。死亡的线程不可再次复生。

sleep()

sleep() 方法是线程类（Thread）的静态方法，让当前正在执行的线程在指定的时间内暂停执行，进入阻塞状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。因为sleep() 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个对象。

wait()

　　wait()方法需要和notify()及notifyAll()两个方法一起介绍，这三个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用，也就是说，调用wait()，notify()和notifyAll()的任务在调用这些方法前必须拥有对象的锁。注意，它们都是Object类的方法，而不是Thread类的方法。
　　wait()方法与sleep()方法的不同之处在于，wait()方法会释放对象的“锁标志”。当调用某一对象的wait()方法后，会使当前线程暂停执行，并将当前线程放入对象等待池（等待池）中，直到调用了notify()方法后，将从对象等待池中移出任意一个线程并放入锁标志等待池（锁池）中，只有锁标志等待池中的线程可以获取锁标志，它们随时准备争夺锁的拥有权。当调用了某个对象的notifyAll()方法，会将对象等待池中的所有线程都移动到该对象的锁标志等待池。
　　除了使用notify()和notifyAll()方法，还可以使用带毫秒参数的wait(long timeout)方法，效果是在延迟timeout毫秒后，被暂停的线程将被恢复到锁标志等待池。
　　此外，wait()，notify()及notifyAll()只能在synchronized语句中使用，但是如果使用的是ReenTrantLock实现同步，该如何达到这三个方法的效果呢？解决方法是使用ReenTrantLock.newCondition()获取一个Condition类对象，然后Condition的await()，signal()以及signalAll()分别对应上面的三个方法。

下面用一个例子来演示：

public class SleepAndWait {

    static class MyResourse {
        public void mySleep(){
            synchronized(this){
                try{
                    System.out.println(Thread.currentThread().getName()+"\t【T1线程获取锁-开始唤醒T2线程】 时间："+System.currentTimeMillis());
                    this.notify();
                    Thread.sleep(5000);
                    System.out.println(Thread.currentThread().getName()+"\t【T1线程结束-释放锁】 时间："+System.currentTimeMillis());
                }
                catch(Exception e){
                    e.printStackTrace();
                }
            }
        }
        public void myWait(){
            synchronized(this){
                try{
                    System.out.println(Thread.currentThread().getName()+"\t【T2线程等待开始-释放锁】 时间："+System.currentTimeMillis());
                    this.wait(Integer.MAX_VALUE);
                    System.out.println(Thread.currentThread().getName()+"\t【T2线程结束】 时间："+System.currentTimeMillis());
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        }

    }

    public static void main(String[] args) {
        MyResourse myResourse =new MyResourse();
        new Thread(()->{
            myResourse.myWait();
        },"T2线程(wait)").start();
        //暂停一会，让T2线程优先执行
        try {TimeUnit.MILLISECONDS.sleep(100);}catch(Exception e){e.printStackTrace();}
        new Thread(()->{
            myResourse.mySleep();
        },"T1线程(sleep)").start();
    }
    
}

运行结果：

tip:关于对象等待池和锁池的理解

　　对于 Java 虚拟机中运行程序的每个对象来说都有两个池，锁 (monitor) 池和等待 (wait) 池。如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。

综上所诉：
sleep() 和 wait() 的区别就是调用sleep方法的线程不会释放对象锁，而调用wait() 方法会释放对象锁

yield()

yield()方法和sleep()方法类似，也不会释放“锁标志”，区别在于，它没有参数，即yield()方法只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行，另外yield()方法只能使同优先级或者高优先级的线程得到执行机会，这也和sleep()方法不同。

join()

join()方法会使当前线程等待调用join()方法的线程结束后才能继续执行，例如：

public class JoinDome {

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
			public void run() {
				 for (int i = 0; i < 10; i++) {
			            System.out.println("线程1第" + i + "次执行！");
			        }
			}
		});
        thread.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程第" + i + "次执行！");
            if (i >= 2)
                try {
                    //t1线程合并到主线程中，主线程停止执行过程，转而执行t1线程，直到t1执行完毕后继续。
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }
    }
}

程序运行结果如下:

主线程第0次执行！
线程1第0次执行！
主线程第1次执行！
主线程第2次执行！
线程1第1次执行！
线程1第2次执行！
线程1第3次执行！
线程1第4次执行！
线程1第5次执行！
线程1第6次执行！
线程1第7次执行！
线程1第8次执行！
线程1第9次执行！
主线程第3次执行！
主线程第4次执行！
主线程第5次执行！
主线程第6次执行！
主线程第7次执行！
主线程第8次执行！
主线程第9次执行！