sleep()、wait()、join()、yield()的区别

爱上口袋的天空

已于 2023-10-19 16:31:07 修改

阅读量191

点赞数 1

分类专栏： # 多线程文章标签： java

于 2021-08-29 23:21:47 首次发布

多线程专栏收录该内容

58 篇文章 2 订阅

订阅专栏

1、锁池

所有需要竞争同步锁的线程都会放在锁池当中，比如当前对象的锁已经被其中一个线程得到，则其他线程需要在这个锁池进行等待，当前面的线程释放同步锁后锁池中的线程去竞争同步锁，当某个线程得到后会进入就绪队列进行等待cpu资源分配。

2、等待池

当我们调用wait（）方法后，线程会放到等待池当中，等待池的线程是不会去竞争同步锁。只有调用了notify（）或notifyAll()后等待池的线程才会开始去竞争锁，notify（）是随机从等待池选出一个线程放到锁池，而notifyAll()是将等待池的所有线程放到锁池当中

3、sleep

sleep 方法是属于 Thread 类中的，sleep 过程中线程不会释放锁，只会阻塞线程，让出cpu给其他线程，但是他的监控状态依然保持着，当指定的时间到了又会自动恢复运行状态，可中断，sleep 给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会。

sleep方法不依赖于同步器synchronized，但是wait需要依赖synchronized关键字
sleep不需要被唤醒（休眠之后推出阻塞），但是wait需要（不指定时间需要被别人中断）
sleep 一般用于当前线程休眠，或者轮循暂停操作，wait 则多用于多线程之间的通信
sleep 会让出 CPU 执行时间且强制上下文切换，而 wait 则不一定，wait 后可能还是有机会重新竞争到锁继续执行的。

示例代码：
/**
 * 线程sleep测试
 *
 * @author supu
 * @date 2019-07-01 9:59
 **/
public class ThreadSleepTest {
    private static final Object obj = new Object();
 
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread1());
        Thread t2 = new Thread(new MyThread2());
        t1.start();
        t2.start();
    }
 
    static class MyThread1 implements Runnable {
 
        @Override
        public void run() {
            synchronized (obj) {
                System.out.println("thread1 start");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread1 end");
            }
        }
    }
 
    static class MyThread2 implements Runnable {
 
        @Override
        public void run() {
            synchronized (obj) {
                System.out.println("thread2 start");
                System.out.println("thread2 end");
            }
        }
    }
}
运行结果：

4、wait

wait 方法是属于 Object 类中的，wait 过程中线程会释放对象锁，只有当其他线程调用 notify 才能唤醒此线程。wait 使用时必须先获取对象锁，即必须在 synchronized 修饰的代码块中使用，那么相应的 notify 方法同样必须在 synchronized 修饰的代码块中使用，如果没有在synchronized 修饰的代码块中使用时运行时会抛出IllegalMonitorStateException的异常。

示例代码：

package com.springboot.demo.thread;
 
/**
 * 线程wait测试类
 *
 * @author supu
 * @date 2019-06-28 17:35
 **/
public class ObjectWaitTest {
    private static final Object obj = new Object();
 
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread1());
        Thread t2 = new Thread(new MyThread2());
        t1.start();
        t2.start();
    }
 
    static class MyThread1 implements Runnable {
 
        @Override
        public void run() {
            synchronized (obj) {
                System.out.println("thread1 start");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread1 end");
            }
        }
    }
 
    static class MyThread2 implements Runnable {
 
        @Override
        public void run() {
            synchronized (obj) {
                System.out.println("thread2 start");
                obj.notify();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread2 end");
            }
        }
    }
}

运行结果：

5、yield

和 sleep 一样都是 Thread 类的方法，都是暂停当前正在执行的线程对象，不会释放资源锁，和 sleep 不同的是 yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。还有一点和 sleep 不同的是 yield 方法只能使同优先级或更高优先级的线程有执行的机会

示例代码：

package com.springboot.demo.thread;
 
/**
 * yield测试
 *
 * @author supu
 * @date 2019-06-28 18:02
 **/
public class ThreadYieldTest {
    private static final Object obj = new Object();
 
    public static void main(String[] args) {
        Thread t3 = new Thread(new MyThread3());
        Thread t1 = new Thread(new MyThread1());
        Thread t2 = new Thread(new MyThread2());
        t3.start();
        t1.start();
        t2.start();
    }
 
    static class MyThread1 implements Runnable {
 
        @Override
        public void run() {
            synchronized (obj) {
                System.out.println("thread1 start");
                Thread.yield();
                System.out.println("thread1 end");
            }
        }
    }
 
    static class MyThread2 implements Runnable {
 
        @Override
        public void run() {
            synchronized (obj) {
                System.out.println("thread2 start");
                System.out.println("thread2 end");
            }
        }
    }
 
    static class MyThread3 implements Runnable {
 
        @Override
        public void run() {
            System.out.println("thread3 start");
            Thread.yield();
            System.out.println("thread3 end");
        }
    }
}

运行结果：

6、join

等待调用join方法的线程结束之后，程序再继续执行，一般用于等待异步线程执行完结果之后才能继续运行的场景。例如：主线程创建并启动了子线程，如果子线程中药进行大量耗时运算计算某个数据值，而主线程要取得这个数据值才能运行，这时就要用到 join 方法了

示例代码：

package com.springboot.demo.thread;
 
/**
 * 线程join测试
 *
 * @author supu
 * @date 2019-07-01 11:01
 **/
public class ThreadJoinTest {
    private static final Object obj = new Object();
    private static int count = 0;
 
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyThread1());
        Thread t2 = new Thread(new MyThread2());
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("count:" + count);
    }
 
    static class MyThread1 implements Runnable {
 
        @Override
        public void run() {
            synchronized (obj) {
                System.out.println("thread1 start");
                for (int i = 0; i < 10; i++){
                    count++;
                }
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread1 end");
            }
        }
    }
 
    static class MyThread2 implements Runnable {
 
        @Override
        public void run() {
            synchronized (obj) {
                System.out.println("thread2 start");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < 10; i++){
                    count++;
                }
                System.out.println("thread2 end");
            }
        }
    }
}

运行结果：

7、总结

wait: Object的方法，常和notify(notifyAll)+synchronized一起使用，调用wait后，线程会释放自己持有的锁及cpu资源，进入线程等待池中，等待其他线程唤醒它。

sleep: Thread的方法，可以设置休眠时间，让线程进入就绪状态。在这期间，线程只会释放CPU资源，如果此时持有的锁资源，则不会释放，时间到了之后继续运行。

yield: Thread的方法，有点类似于sleep，只是不能设置时间。它的作用只是让出cpu资源，让自己所在的线程进入就绪状态，告诉cpu可以优先执行其他的线程，有可能刚进入可执行状态，cpu又调度到了该线程。当然如果持有着锁的话，也不会释放。

join: Thread的方法，这是一种特殊的wait,若有两个线程T1,T2,当在T1中调用T2.join后，T1线程就会进入阻塞状态，直到T2线程运行完了，T1才会继续运行。使用时要先调用线程的start,再调用join.

爱上口袋的天空

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
sleep()、wait()、join()、yield()的区别

wait: Object的方法，常和notify(notifyAll)+synchronized一起使用，调用wait后，线程会释放自己持有的锁及cpu资源，进入线程等待池中，等待其他线程唤醒它。sleep: Thread的方法，可以设置休眠时间，让线程进入就绪状态。在这期间，线程只会释放CPU资源，如果此时持有的锁资源，则不会释放，时间到了之后继续运行。yield: Thread的方法，有点类似于sleep，只是不能设置时间。
复制链接

扫一扫