java多线程中的sleep()、yield()、join()和wait()

网上有不少关于sleep()、join()和wait()的文章。比如很多类似这样的标题“Thread的sleep()、join()和wait()”。

严格来讲，这样的标题，不够严谨的背后或者是表达的不精准，也可能是对一些概念的理解有所模糊。

首先：sleep()和yield()方法是Thead的静态方法，而join是Thread的实例方法，wait()是Object的方法。

public
class Thread implements Runnable { 

    public static native void yield();

    public static native void sleep(long millis) throws InterruptedException;

    public final void join() throws InterruptedException {
        join(0);
    }

    ...

}

public class Object {

 public final void wait() throws InterruptedException {
        wait(0);
    }

}

join(long millis)方法：

//由于join方法属于Thread对象，所以这里的同步关键字是把Thread对象（线程）作为锁
//比如：在t1的run()方法中，调用t2.join()，这是指：t1先获取t2的锁，然后判断t2是否存活，
//如果存活那表示t2还未执行完，那么t1就阻塞住，等待t2执行完。
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，释放拥有该方法的线程对像的锁
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

 在上边的源码中，我已加了注释，可以对以上常见做出比较清晰的解释了：

        Thread t2= new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程2开始运行.....");
                    // 此处调用线程t1的join方法，那么是t1阻塞住等待t2执行完，还是t2组塞住等待t1        
                    //执行完？在上边的join方法源码中有分析和注释。
                    //另外，也可以通过语义进行分析：join表示合并，调用t1.join(),语义上讲，就是把
                    //t1合并到t2的路劲上来，有插入的含义，插进来的新路径是要先执行的。
                    t1.join();
                    System.out.println("线程2运行结束.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
      

 

上边的文字描述可能有点抽象，对join的语义“合并插入”，我画了一个图，比较直观一些：

wait()方法：该方法是Object的方法，一般用的时时候，是先new出一个锁对象lock，然后调用锁对象的wait()和notify()/notifyAll()，

如：

      synchronized (lock) {
              while (condition)
                  lock.wait();
              ... // Perform action appropriate to condition
          }

上边是从网上找到一些说明： 

1 sleep

  sleep()会让线程交出CPU的执行权，但是不会释放锁。

 

public class ThreadSleep {

    //定义锁
    private static final Object LOCK = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程1开启运行....");
                synchronized (LOCK){
                    try {
                        System.out.println("线程1抢到了锁....");
                        Thread.sleep(2000);
                        System.out.println("线程1运行结束.....");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程2开启运行....");
                synchronized (LOCK){
                    System.out.println("线程2抢到了锁....");
                    System.out.println("线程2运行结束.....");
                }
            }
        });

        thread1.start();//开启线程1
        //让主线程稍等片刻,确保线程1已经运行
        Thread.sleep(300);
        thread2.start();//开启线程2
    }
}

 

线程1开启运行....
线程1抢到了锁....
线程2开启运行....
线程1运行结束.....
线程2抢到了锁....
线程2运行结束.....

  从运行的结果可以看到，线程1先开始执行，在线程1拿到锁后，线程2也开始执行，但是此时是线程1持有锁，所以线程2阻塞，当线程1开始睡眠时，线程2还是没有拿到锁，直到线程1运行结束释放了锁后，线程2才继续运行。
  所以，sleep()不释放锁。

  yield()和sleep方法相似，也会交出CPU的执行权，也不会释放锁，两者之间的区别有

(1) sleep()会使线程进入阻塞状态，yield()不会时线程进入阻塞态而是进入可运行态，当线程重新获得CPU执行权后又可以执行。
(2) sleep()释放CPU后其他都可以竞争CPU的执行权，而yield()只会让线程优先级大于等于自己的线程竞争CPU执行权的机会。

2 join

  join()可以保证让一个线程在另一个线程之前执行结束。如何保证一个工作在另一个工作结束之前完成，就可以使用join()方法。

 

public class JoinThread {

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程1开始运行.....");
                    // 为了验证线程1在线程2之前运行结束，这里让线程1睡眠3秒
                    Thread.sleep(3000);
                    System.out.println("线程1运行结束.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程2开始运行.....");
                    thread1.join();// 线程2运行到这里会等待线程1运行结束
                    System.out.println("线程2运行结束.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread2.start();// 先开启线程2
        Thread.sleep(200);
        thread1.start();// 在开启线程1
    }
}

 

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

  线程2先启动，当运行到thread1.join()时，线程2停止运行，等待线程1执行结束，虽然线程1启动比线程2迟，但是只有当线程1运行结束后，线程2才能继续运行。

wait

  wait()可以让线程从运行态转换为阻塞态，同时还会释放线程的同步锁。

 

/**  
* <p>Title: T.java</p>  
* <p>Description: </p>  
* <p>Copyright: </p>  
* <p>Company: </p>  
* @author wangzhj
* @date 2020年1月8日  
* @version 1.0  
*/  
 package com.yky.commons.tools.file.reload;

 /**  
* <p>Title: T</p>  
* <p>Description: </p>  
* @author wangzhj 
* @date 2020年1月8日  
*/
 public class T {
     private static Object lock = new Object();
     public static boolean flag = true;
     
     public static void main(String[] args) throws InterruptedException {

         Thread thread1 = new Thread(new Runnable() {
             @Override
             public  void run() {
                 synchronized(lock) {
                 while(flag) {
                     try {
                        
                         System.out.println("线程1抢到了锁....");
                         lock.wait();
                         
                         
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
                 System.out.println("线程1运行结束.....");
             }
             }
         });

         Thread thread2 = new Thread(new Runnable() {
             @Override
             public void run() {
                 synchronized(lock) {
                     System.out.println("线程2抢到了锁....");
                     System.out.println("线程2运行结束.....");
                     flag = false;
                     lock.notify();
                 }
             }
         });
         thread1.start();//开启线程1
         //让主线程稍等片刻,确保线程1已经运行
         Thread.sleep(200);
         thread2.start();//开启线程2
     }
 }

  运行结果：线程2运行结束后，由于线程1没有被唤醒，所以一直阻塞在那里......可以使用带有参数的wait(long mills)，当等待的时间结束后，线程会被自动唤醒。

 

线程1抢到了锁....
线程2抢到了锁....
线程2运行结束.....
线程1运行结束.....

本文完

参考引用链接：

https://www.jianshu.com/p/446b2fcec642

注意：该链接的wait()解释中，给出的代码有点问题：

public class ThreadWait {

    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public synchronized void run() {
                    try {
                        System.out.println("线程1抢到了锁....");
                        this.wait();
                        System.out.println("线程1运行结束.....");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public synchronized void run() {
                System.out.println("线程2抢到了锁....");
                System.out.println("线程2运行结束.....");
            }
        });
        thread1.start();//开启线程1
        //让主线程稍等片刻,确保线程1已经运行
        Thread.sleep(200);
        thread2.start();//开启线程2
    }
}

问题分析：

上边的代码，锁关键字synchronized加在了run方法上，锁对象成为了两个线程对象，两把锁。所以如果这里有wait()，notify()，是有问题的。用synchronized关键字时要确保，wait()和notify()获取的锁是同一个对象。