Thread的sleep()、join()和wait()

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()可以让线程从运行态转换为阻塞态，同时还会释放线程的同步锁。

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
    }
}

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

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

本文完