并发系列之线程面试重点方法

京都大学（日本）校训：“自由的学风。”

---

今晚说有雷暴没来，蒸笼确阴魂不散，持续40度的高温，真心受不了。无奈之下，吃个火锅降降暑，顺便小酌两杯，消除心中的暑气，不免快哉！不扯了，今晚讲点干货，介绍工作中常用的关于线程的重点方法，也是面试的重要询问点。

一 sleep & wait/notify/notifyAll

1 sleep

a/ sleep是Thread的静态native方法，旨在让当前线程暂停一定的时间，不涉及线程间的通信；
b/ sleep只是暂时让出CPU的执行权，并不释放锁；
c/ sleep可通过interrupt()打断线程的暂停状态；
d/ sleep无需非要在同步代码块中执行，而wait只能在同步或加锁的代码块中进行，这也是为何wait能够实现线程间通信的缘由；
e/ sleep在工作代码中很少用到，主要在程序调试的情形下使用。

2 wait/notify/notifyAll

a/ wait/notify/notifyAll是Object的native方法，为何设置为Object的方法呢，因为在Java世界里万物皆对象，锁自然也是对象，同样对象也是一把锁，这样巧妙地设计真是彰显出设计者的优秀；
b/ wait/notify通常是成对使用，当然也可单独使用wait来代替sleep，wait可设置等待一定的时候后自行竞争获取CPU执行权；
c/ wait可通过interrupt()打断线程的等待状态；
d/ wait/notify/notifyAll只能在同步或加锁的代码块中使用；
e/ notify旨在唤醒对象锁上等待池中的线程，具有随机性（视不同的虚拟机而定，HotSpot是唤醒等待池中的第一个），因而在实际中经常使用notifyAll，它是唤醒对象锁上等待池中的所有线程，而且是按照LIFO(后进先出)的方式进入对象锁的锁池进行锁竞争；
f/ 当线程调用wait方法，则会释放锁，进入锁对象的等待池，被notify后进入锁对象的锁池进行锁竞争。
demo世界不孤单，请阅：

/**
 * @author 阿伦故事
 * @Description：描述sleep & wait对比
 * sleep：主动放弃CPU执行权，但不释放锁，似乎只在调试程序时有用
 * wait：放弃CPU执行权，并释放锁，是线程间通信的重要方式
 * */
@Slf4j
public class SleepAndWait {
    public static void main(String[] args) throws InterruptedException{
        SleepAndWait sleepAndWait = new SleepAndWait();
        log.info("--begin sleep test--");
        for (int i = 0; i < 5; i++) {
            new Thread(()-> sleepAndWait.sleepTest()).start();
        }
        Thread.sleep(15000);
        log.info("--end sleep test--");
        log.info("--begin wait test--");
        for (int i = 0; i < 5; i++) {
            new Thread(()-> sleepAndWait.waitTest()).start();
        }
        Thread.sleep(1000);
        log.info("--notify sleepAndWait对象头上的所有锁 --");
        new Thread(()-> {synchronized (sleepAndWait){sleepAndWait.notify();}}).start();
        Thread.sleep(1000);
        log.info("--end wait test--");
        log.info("--stop the world--");
    }
    /**
     * sleep test
     * */
    public synchronized void sleepTest(){
        log.info("--thread name："+Thread.currentThread().getName()+" begin sleep--");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("--thread name："+Thread.currentThread().getName()+" end sleep--");
    }
    /**
     * wait test
     * */
    public synchronized void waitTest(){
        log.info("--thread name："+Thread.currentThread().getName()+" begin wait--");
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("--thread name："+Thread.currentThread().getName()+" end wait--");
    }
}

二 join & yield

1 join

a/ join是Thread的普通方法，旨在当前线程等待调用join的线程执行结束；
b/ join可设置等待时长，超时后join失效；
c/ join可通过interrupt()打断线程的等待状态；
demo世界不孤单，请阅：

/**
 * @author 阿伦故事
 * @Description：描述join & yield
 * */
@Slf4j
public class JoinAndYield {

    public static void main(String[] args) throws InterruptedException{
        JoinAndYield sleepAndWait = new JoinAndYield();
        //join test
        sleepAndWait.joinTest();
    }
    /**
     * join：等待线程的销亡
     * */
    public void joinTest() throws InterruptedException{
        log.info("--create sub thread--");
        Thread thread = new Thread(()->{
            log.info("--sub thread begin run--");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.info("--sub thread end run--");
        });
        thread.start();
        thread.join();
        log.info("--stop the world--");
    }
}

2 yield

a/ yield是Thread的静态native方法，旨在让出当前线程的CPU执行权，以便给同等优先级的线程更高概率获取执行权；
b/ yield是将当前线程从运行状态转变到就绪状态，但并不能保证是立即转换，另转换后还是有一定概率再次获取CPU执行权的；
c/ 执行yield的线程是不会释放锁的。
demo世界不孤单，请阅：

/**
 * @author 阿伦故事
 * @Description：描述join & yield
 * */
@Slf4j
public class JoinAndYield {

    public static void main(String[] args) throws InterruptedException{
        JoinAndYield sleepAndWait = new JoinAndYield();
        //yield test
        sleepAndWait.yieldTest();
    }
    /**
     * yield：使线程运行状态转为就绪状态，让度CPU执行权
     * */
    public void yieldTest() throws InterruptedException{
        Thread thread1 = new Thread(()->{
            log.info("--thread1 begin run--");
            for (int i = 0; i < 5 ; i++) {
                log.info("--thread1 create i："+i);
            }
            log.info("--thread1 end run--");
        });
        Thread thread2 = new Thread(()->{
            log.info("--thread2 begin run--");
            for (int i = 0; i < 5 ; i++) {
                log.info("--thread2 create i："+i);
            }
            log.info("--thread2 end run--");
        });
        thread1.start();
        thread1.join();
        thread2.start();
    }
}

---

特此声明：
分享文章有完整的知识架构图，将从以下几个方面系统展开：
1 基础（Linux/Spring boot/并发）
2 性能调优（jvm/tomcat/mysql）
3 高并发分布式
4 微服务体系
如果您觉得文章不错，请关注阿伦故事，您的支持是我坚持的莫大动力，在此受小弟一拜！

---

每篇福利：

评论区打出车型.jpg