Java多线程中join、yield、sleep方法详解

在Java多线程编程中，Thread类是其中一个核心和关键的角色。因此，对该类中一些基础常用方法的理解和熟练使用是开发多线程代码的基础。本篇主要总结一下Thread中常用的一些静态方法的含义及代码中的使用。

sleep方法

源码如下：

    /**
     * Causes the currently executing thread to sleep (temporarily cease
     * execution) for the specified number of milliseconds, subject to
     * the precision and accuracy of system timers and schedulers. The thread
     * does not lose ownership of any monitors.
     *
     * @param  millis
     *         the length of time to sleep in milliseconds
     *
     * @throws  IllegalArgumentException
     *          if the value of {@code millis} is negative
     *
     * @throws  InterruptedException
     *          if any thread has interrupted the current thread. The
     *          <i>interrupted status</i> of the current thread is
     *          cleared when this exception is thrown.
     */
    public static native void sleep(long millis) throws InterruptedException;

可以看到sleep是一个静态的本地方法，因为是本地方法，所以并没有java代码的实现，其实是调用了底层的C库函数来实现的睡眠。

有一个long类型的参数，表示睡眠多少毫秒。

阅读注释，sleep方法的含义就是，让当前正在执行任务的线程睡眠（临时地停止执行）指定的毫秒数，这个精度和准确性是用系统时钟和调度器保证的。但是，线程并不会释放它拥有的锁。

注意该方法会抛出InterruptedException中断异常。

sleep不会释放锁代码示例：

public class ThreadsleepDemo{

    private Object object = new Object();

    public static void main(String[] args) {

        ThreadsleepDemo threadsleepDemo = new ThreadsleepDemo();
        Thread thread1 = threadsleepDemo.new SleepDemoThread();
        thread1.setName("线程1");
        Thread thread2 = threadsleepDemo.new SleepDemoThread();
        thread2.setName("线程2");
        thread1.start();
        thread2.start();

    }

    class SleepDemoThread extends Thread{
        @Override
        public void run() {
            synchronized (object){
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        }
    }
}

输出结果如下：

线程1开始运行
线程1运行结束
线程2开始运行
线程2运行结束

可以多运行几次，可能会有线程1在上面或和线程2在上面，但始终都是一个行程运行完了才会运行另一个线程，中间不会插入进来一个线程运行。

yield方法

  /**
     * A hint to the scheduler that the current thread is willing to yield
     * its current use of a processor. The scheduler is free to ignore this
     * hint.
     *
     * <p> Yield is a heuristic attempt to improve relative progression
     * between threads that would otherwise over-utilise a CPU. Its use
     * should be combined with detailed profiling and benchmarking to
     * ensure that it actually has the desired effect.
     *
     * <p> It is rarely appropriate to use this method. It may be useful
     * for debugging or testing purposes, where it may help to reproduce
     * bugs due to race conditions. It may also be useful when designing
     * concurrency control constructs such as the ones in the
     * {@link java.util.concurrent.locks} package.
     */
    public static native void yield();

当前线程对调度器的一个暗示，表示愿意让出CPU执行器的当前使用权，但是调度器可以自由忽略这个提示。

Yeild是一种在可能会过度使用一个CPU的多个线程之间提升相对进度试探性尝试。它的使用应该结合详细的性能分析和基准测试来进行，确保它确实有预期的效果。

很少使用这种方法。 它可能对调试或测试有用，可能有助于根据竞态条件重现错误。 在设计并发控制结构（例如java.util.concurrent.locks包中的并行控制结构）时也可能有用。

join方法

join有三个重载的方法

join()
join(long millis)
join(long millis,int nanoseconds)

主要看下第二个方法的源码

    /**
     * Waits at most {@code millis} milliseconds for this thread to
     * die. A timeout of {@code 0} means to wait forever.
     *
     * <p> This implementation uses a loop of {@code this.wait} calls
     * conditioned on {@code this.isAlive}. As a thread terminates the
     * {@code this.notifyAll} method is invoked. It is recommended that
     * applications not use {@code wait}, {@code notify}, or
     * {@code notifyAll} on {@code Thread} instances.
     */
    public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

就是等待一个线程指定毫秒数后再消亡。无参数的join方法其实就是调用了join(0)，即永远等待下去。不过通过源码我们可以看到，在while循环中有一个条件判断，即isAlive()方法，意思是如果当前线程还活着，就会一直等待下去。

有点懵，看个例子应该加深下理解。比如睡前想刷个抖音。

刷抖音的工作我们交给一个线程来完成。

public class ScanDouyin extends Thread{

    // 浏览抖音的时长
    private int scanTime;

    public ScanDouyin(String name, int scanTime){
        super(name);
        scanTime = this.scanTime;
    }
    @Override
    public void run() {
        System.out.println(getName() + ":开始刷抖音了");
        try {
            // 刷抖音的时间
            sleep(scanTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getName() +":抖音刷完了，睡觉吧");
    }
}

下面是准备睡觉的线程

/**
 *  准备睡觉了,睡前想要刷个抖音
 */
public class ReadySleep extends Thread{

    private ScanDouyin scanDouyin;

    public ReadySleep(String name,ScanDouyin scanDouyin){
        super(name);
        this.scanDouyin = scanDouyin;
    }
    @Override
    public void run() {
        System.out.println(getName() + ":准备开始睡觉啦");
        try {
            // 睡前刷把抖音
            scanDouyin.join();

            // 准备睡觉的具体内容
            System.out.println("开始睡觉");
            sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getName() + ":zzzzzzzz,已经睡着了");
    }

    public static void main(String[] args) {
        ScanDouyin scanDouyin = new ScanDouyin("刷抖音线程",10000);
        ReadySleep readySleep = new ReadySleep("睡觉线程",scanDouyin);
        readySleep.start();
        scanDouyin.start();

    }
}

输出结果如下：

睡觉线程:准备开始睡觉啦
刷抖音线程:开始刷抖音了
刷抖音线程:抖音刷完了，睡觉吧
开始睡觉
睡觉线程:zzzzzzzz,已经睡着了

这里我们我设置的刷抖音的时间是10s,睡觉线程的执行时间是100ms，也就是0.1s。

可以看到因为在睡觉线程中调用了刷抖音线程的join方法，使得睡觉的线程必须等待直到刷完抖音（刷抖音线程执行完毕，线程消亡），才能开始睡觉。

至此，应该可以明白，如果某个线程在另一个线程t上调用t.join()，此线程将被挂起，直到目标线程t结束才恢复（即t.isAlive()方法返回假）。