专栏首页Java进阶指南线程sleep,wait,notify,join,yield方法解析

线程sleep,wait,notify,join,yield方法解析

线程的五种状态

线程从创建到销毁一般分为五种状态,如下图:

1) 新建

当用new关键字创建一个线程时,就是新建状态。

2) 就绪

调用了 start 方法之后,线程就进入了就绪阶段。此时,线程不会立即执行run方法,需要等待获取CPU资源。

3) 运行

当线程获得CPU时间片后,就会进入运行状态,开始执行run方法。

4) 阻塞

当遇到以下几种情况,线程会从运行状态进入到阻塞状态。

  • 调用sleep方法,使线程睡眠。
  • 调用wait方法,使线程进入等待。
  • 当线程去获取同步锁的时候,锁正在被其他线程持有。
  • 调用阻塞式IO方法时会导致线程阻塞。
  • 调用suspend方法,挂起线程,也会造成阻塞。

需要注意的是,阻塞状态只能进入就绪状态,不能直接进入运行状态。因为,从就绪状态到运行状态的切换是不受线程自己控制的,而是由线程调度器所决定。只有当线程获得了CPU时间片之后,才会进入运行状态。

5) 死亡

当run方法正常执行结束时,或者由于某种原因抛出异常都会使线程进入死亡状态。另外,直接调用stop方法也会停止线程。但是,此方法已经被弃用,不推荐使用。

线程常用方法

1)sleep

当调用 Thread.sleep(long millis) 睡眠方法时,就会使当前线程进入阻塞状态。millis参数指定了线程睡眠的时间,单位是毫秒。当时间结束之后,线程会重新进入就绪状态。

注意,如果当前线程获得了一把同步锁,则 sleep方法阻塞期间,是不会释放锁的。

2) wait、notify和notifyAll

首先,它们都是Object类中的方法。需要配合 Synchronized关键字来使用。

调用线程的wait方法会使当前线程等待,直到其它线程调用此对象的notify/notifyAll方法。如果,当前对象锁有N个线程在等待,则notify方法会随机唤醒其中一个线程,而notifyAll会唤醒对象锁中所有的线程。需要注意,唤醒时,不会立马释放锁,只有当前线程执行完之后,才会把锁释放。

另外,wait方法和sleep方法不同之处,在于sleep方法不会释放锁,而wait方法会释放锁。wait、notify的使用如下:

public class WaitTest {
    private static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        ListAdd listAdd = new ListAdd();

        Thread t1 = new Thread(() -> {
            synchronized (obj){
                try {
                    for (int i = 0; i < 10; i++) {
                        listAdd.add();
                        System.out.println("当前线程:"+Thread.currentThread().getName()+"添加了一个元素");
                        Thread.sleep(300);
                        if(listAdd.getSize() == 5){
                            System.out.println("发出通知");
                            obj.notify();
                        }
                    }
                } catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (obj){
                try {
                    if(listAdd.getSize() != 5){
                        obj.wait();
                    }
                } catch(InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println("线程:"+Thread.currentThread().getName()+"被通知.");
            }

        });

        t2.start();
        Thread.sleep(1000);
        t1.start();
    }
}

class ListAdd {
    private static volatile List<String> list = new ArrayList<String>();

    public void add() {
        list.add("abc");
    }

    public int getSize() {
        return list.size();
    }
}

以上,就是创建一个t2线程,判断list长度是否为5,不是的话,就一直阻塞。然后,另外一个t1线程不停的向list中添加元素,当元素长度为5的时候,就去唤醒阻塞中的t2线程。

然而,我们会发现,此时的t1线程会继续往下执行。直到方法执行完毕,才会把锁释放。t1线程去唤醒t2的时候,只是让t2具有参与锁竞争的资格。只有t2真正获得了锁之后才会继续往下执行。

3) join

当线程调用另外一个线程的join方法时,当前线程就会进入阻塞状态。直到另外一个线程执行完毕,当前线程才会由阻塞状态转为就绪状态。

或许,你在面试中,会被问到,怎么才能保证t1,t2,t3线程按顺序执行呢。(因为,我们知道,正常情况下,调用start方法之后,是不能控制线程的执行顺序的)

咳咳,当前青涩的我,面试时就被问到这个问题,是一脸懵逼。其实,是非常简单的,用join方法就可以轻松实现:

public class TestJoin {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new MultiT("a"));
        Thread t2 = new Thread(new MultiT("b"));
        Thread t3 = new Thread(new MultiT("c"));
        
        t1.start();
        t1.join();

        t2.start();
        t2.join();

        t3.start();
        t3.join();
    }

}

class MultiT implements Runnable{
    private String s;
    private int i;

    public MultiT(String s){
        this.s = s;
    }

    @Override
    public void run() {
        while(i<10){
            System.out.println(s+"===="+i++);
        }
    }
}

最终,我们会看到,线程会按照t1,t2,t3顺序执行。因为,主线程main总会等调用join方法的那个线程执行完之后,才会往下执行。

4) yield

Thread.yield 方法会使当前线程放弃CPU时间片,把执行机会让给相同或更高优先级的线程(yield英文意思就是屈服,放弃的意思嘛,可以理解为当前线程暂时屈服于别人了)。

注意,此时当前线程不会阻塞,只是进入了就绪状态,随时可以再次获得CPU时间片,从而进入运行状态。也就是说,其实yield方法,并不能保证,其它相同或更高优先级的线程一定会获得执行权,也有可能,再次被当前线程拿到执行权。

yield方法和sleep方法一样,也是不释放锁资源的。可以通过代码来验证这一点:

public class TestYield {
    public static void main(String[] args) {
        YieldThread yieldThread = new YieldThread();
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(yieldThread);
            t.start();
        }
    }
}

class YieldThread implements Runnable {

    private int count = 0;

    @Override
    public synchronized void run() {
        for (int i = 0; i < 10; i++) {
            count ++;
            if(count == 1){
                Thread.yield();
                System.out.println("线程:"+Thread.currentThread().getName() + "让步");
            }
            System.out.println("线程:"+Thread.currentThread().getName() + ",count:"+count);
        }
    }
}

结果:

会看到,线程让步之后,并不会释放锁。因此,其它线程也没机会获得锁,只能把当前线程执行完之后,才会释放。(对于这一点,其实我是有疑问的。既然yield不释放锁,那为什么还要放弃执行权呢。就算放弃了执行权,别的线程也无法获得锁啊。)

所以,我的理解,yield一般用于不存在锁竞争的多线程环境中。如果当前线程执行的任务时间可能比较长,就可以选择用yield方法,暂时让出CPU执行权。让其它线程也有机会执行任务,而不至于让CPU资源一直消耗在当前线程。

5)suspend、resume

suspend 会使线程挂起,并且不会自动恢复,只有调用 resume 方法才能使线程进入就绪状态。注意,这两个方法由于有可能导致死锁,已经被废弃。

本文分享自微信公众号 - 烟雨星空(mistyskys),作者:烟雨星空

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2020-02-29

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • sleep() wait() yield() join()傻傻风不清楚?

    sleep()方法需要指定等待的时间,它可以让当前正在执行的线程在指定的时间内暂停执行,进入阻塞状态。可以让其他同优先级或者高优先级的线程得到执行的机会,也可以...

    Leetcode名企之路
  • wait方法和sleep方法的区别

    一.概念、原理、区别 Java中的多线程是一种抢占式的机制而不是分时机制。线程主要有以下几种状态:可运行,运行,阻塞,死亡。抢占式机制指的是有多个线程处于可运...

    老白
  • Java 多线程中wait、notify、nptifyAll、yield、join、sleep的使用方法及区别

    在Java多线程编程中,会涉及到wait、notify、nptifyAll、yield、join、sleep线程间交互的方法,这些比较晦涩难懂,现在全面介绍下这...

    夹胡碰
  • join方法及其调用yield sleep wait notify方法会对锁产生的影响

    线程A执行了线程B的join方法,,线程A必须要等线程B执行完成后,线程A才能继续执行

    彼岸舞
  • 线程常用方法对比

    Java平台中,因为有内置锁的机制,每个对象都可以承担锁的功能。Java虚拟机会为每个对象维护两个“队列”(姑且称之为“队列”,尽管它不一定符合数据结构上队列的...

    黑洞代码
  • 多线程之间实现通讯,join,yield,lock

    答:多线程之间的通讯,就是多个线程操作同一个全局变量时候,做的操作不同。如一个读,一个写。

    斯文的程序
  • 性能优化必备之线程状态浅析

    2、就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于“可运行线程池”中,变得可运行,只等待获取CPU的使...

    周辰晨
  • (十二)yield、notify、notifyAll、sleep、join、wait(三)

    Object.wait(long)要跟Object.notify()/notifyAll()搭配使用。

    HaC
  • 你能说出多线程中 sleep、yield、join 的用法及 sleep与wait区别吗?

    Object中的wait、notify、notifyAll,可以用于线程间的通信,核心原理为借助于监视器的入口集与等待集逻辑

    用户1516716
  • sleep、yield、join方法简介与用法 sleep与wait区别 多线程中篇(十四)

    Object中的wait、notify、notifyAll,可以用于线程间的通信,核心原理为借助于监视器的入口集与等待集逻辑

    noteless
  • 线程Thread相关知识点总结

    在Java中创建线程其中两种最基本的方法:使用Thread类和使用Runnable接口。要注意的是Thread类也实现了Runnable接口,因此从T...

    java乐园
  • Java并发编程的艺术(四)——线程的状态

    线程的状态 初始态:NEW 创建一个Thread对象,但还未调用start()启动线程时,线程处于初始态。 运行态:RUNNABLE 在Java中,运行态包括...

    大闲人柴毛毛
  • 线程常用方法辨析(2)

    2. yield()方法的意思是告诉CPU执行其他的线程,当前线程让出CPU的执 行权利

    黑洞代码
  • JAVA 线程

    //Executors 工具类 //ExecutorService 接口 ExecutorService service = Executors.newFix...

    Dean0731
  • 300 行代码带你秒懂 Java 多线程!

    线程(英语:Thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中...

    美的让人心动
  • “面试不败计划”:java工程师面试常问的多线程问题【推荐】

    好好学java
  • 线程的基本操作

    用户1216491
  • (2021最新版)Java后端面试题|Java多线程与并发

    面试前还是很有必要针对性的刷一些题,很多朋友的实战能力很强,但是理论比较薄弱,面试前不做准备是很吃亏的。这里整理了很多面试常考的一些面试题,希望能帮助到你面试前...

    程序员追风
  • Java并发编程(一)

    昨天忘关电脑了,今天极其极其慢,开了没几个应用,一卡一卡,同步打开几个笔记都卡到不能加载,平时上网课吧,小伙伴说不系统,那根据网课的大纲白*自己找资料不香么...

    疯狂的KK

扫码关注云+社区

领取腾讯云代金券