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

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运行结束…
本文完