并发编程学习笔记（五、线程中常用的方法）

目录：

• sleep()
• wait()
• notify()/notifyAll()
• yieid()
• join()
• 总结

sleep()：

1、sleep()方法的作用是让线程暂停指定的毫秒数。

2、sleep()方法只是暂时交出CPU的执行权，并非释放锁。

3、sleep()方法不需要在synchronize块中执行，而wait()方法需要。

4、sleep()可以通过interrupt()方法打断休眠状态。

5、sleep()只是操作线程，并不涉及线程间的通信。

public class SleepTest {
    /**
     * sleep()方法不会释放锁，因此线程是按照先后顺序执行的
     */
    public synchronized void sleepMethod() {
        System.out.println("Sleep start ： " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Sleep end ： " + Thread.currentThread().getName());
    }

    /**
     * wait()方法会释放锁，因此一旦调用wait()方法就会造成其他线程运行
     */
    public synchronized void waitMethod() {
        System.out.println("Wait start ： " + Thread.currentThread().getName());
        synchronized (this) {
            try {
                wait(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Wait end ：" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        final SleepTest test1 = new SleepTest();
        for (int i = 0; i < 5; i++) {
            new Thread(test1::sleepMethod).start();
        }

        try {
            //暂停十秒，等上面程序执行完成
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("-----分割线-----");

        final SleepTest test2 = new SleepTest();
        for (int i = 0; i < 5; i++) {
            new Thread(test2::waitMethod).start();
        }
    }
}

sleep都是一个一个执行完，先start再end，从这一现象便知sleep()方法并不会释放锁；而wait则不会交出CPU的执行权。

若将18、20行的synchronize删除，wait()方法便会抛出IllegalMonitorStateException异常，所以wait()方法必须要在synchronize块或synchronize方法中执行。

wait()：

1、wait()、notify()方法通常成对出现。

2、wait()、notify()方法都需要在synchronize块或synchronize方法中执行。

3、wait()方法可以通过interrupt()方法打断暂停状态。

4、通过为wait()方法设置时间（wait(1000)）或调用notify()方法可以让对象重新获取锁。

notify()、notifyAll()：

1、notify()用来唤醒此对象上等待的单个线程，notifyAll()唤醒多个线程。

2、notifyAll()唤醒的顺序为先进后出（类似于栈），Last In First Out。

3、wait()、notify()、notifyAll()涉及线程间的通信。

public class WaitClassDemo {

    private static SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");

    public static void main(String[] args) {
        Object obj = new Object();
        for (int i = 0; i < 5; i++) {
            new WaitThread(i + "", obj).start();
        }
        new NotifyThread(obj).start();
    }

    /**
     * 调用wait()方法的线程
     */
    static class WaitThread extends Thread {
        Object obj;
        public WaitThread(String name, Object obj) {
            setName("WaitThread" + name);
            this.obj = obj;
        }

        @Override
        public void run() {
            synchronized (obj) {
                System.out.println(sdf.format(new Date()) + " " + getName() + " before wait()");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(sdf.format(new Date()) + " " + getName() + " after wait()");
            }
        }
    }

    /**
     * 调用notify()/notifyAll()
     */
    static class NotifyThread extends Thread {
        Object obj;
        public NotifyThread(Object obj) {
            setName("NotifyThread");
            this.obj = obj;
        }

        @Override
        public void run() {
            synchronized (obj) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(sdf.format(new Date()) + " NotifyThread before notify()");
                // 唤醒所有线程 用notifyAll()会按照后进先出（LIFO）的原则恢复线程
                obj.notifyAll();
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(sdf.format(new Date()) + " NotifyThread after notify()");
            }
        }
    }
}

yieId()：

1、作用：告诉CPU你这次分给我的资源我不要了，你去给其它线程吧（￣︶￣）↗

2、注意：

• yieId()方法不能保证其它线程一定能够执行，因为它仍是可执行状态，所以仍有可能被CPU再次执行。
• 执行yieId()方法不会释放锁。

join()：

1、作用：让一个线程在另一个线程执行完后再执行。

2、注意：线程A内部执行线程B的join()方法，那么A将会阻塞，直到线程B执行完后才会执行线程A。

3、Demo：小明点了一个煎饼果子，老板收到订单后便开始做煎饼；那小明肯定是不可能在煎饼果子来之前啥事都不做，老板也一样；所以我们这里用线程来实现他们两个的动作。

public class Consumer {

    public void eat() {
        System.err.println("开始吃煎饼果子...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.err.println("煎饼果子吃完啦...");
    }
}

public class Producer {

    public void manufacture() {
        System.out.println("开始制作煎饼果子...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("煎饼果子制作完成...");
    }
}

public class JoinTest {

    public static void main(String[] args) {
        Thread producerThread = new Thread(() -> {
            Producer producer = new Producer();
            producer.manufacture();
        });
        producerThread.start();

        Thread consumerThread = new Thread(() -> {
            try {
                producerThread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Consumer consumer = new Consumer();
            consumer.eat();
        });
        consumerThread.start();
    }
}

总结：

1、方法调用：sleep()、yieId()都是Thread类的静态方法；join()是Thread类的实例方法；wait()、notify()、notifyAll()是Object类的实例方法。

2、释放锁：Thread.sleep()、Thread.yieId()不会释放锁；wait()会释放锁。

3、执行位置：sleep()、yieId()、join()不一定需要在synchronize块中执行；wait()、notify()、notifyAll()需要在synchronize块中执行，否则会抛出IllegalMonitorStateException。