sleep()、yield()、join()、wait()/notify()、interupt()——多线程中常用的方法

一、sleep()——线程休眠

线程休眠：指的是让线程暂缓执行一下，等到了预计时间之后再恢复执行。

线程休眠会交出CPU，让CPU去执行其他的任务。sleep() 方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep() 方法，其他线程也无法访问这个对象。

使程序从：运行态——>阻塞态

class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(2000);//单位毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("当前线程：" + Thread.currentThread().getName() + "  i = " + i);
        }
    }
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        new Thread(mt).start();
        new Thread(mt).start();
    }
}

通过代码运行之后观察会发现这两个线程是同时休眠的，但是并非我们所看的那样，所有的代码是依次进入到run()方法中的。 真正进入到方法的对象可能是多个，也可能是一个。进入代码的顺序可能有差异，但是总体的执行是并发执行。

二、yield()——线程让步

线程让步：暂停当前正在执行的线程对象，并执行其他线程。

意思就是调用yield() 让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。

使程序从：运行态——>就绪态

这里有个线程优先级的概念：

线程的优先级指的是，线程的优先级越高越有可能先执行（只是有可能而已）

对于优先级设置的内容可以通过Thread类的几个常量来决定

1. 最高优先级：public final static int MAX_PRIORITY = 10;

2. 中等优先级：public final static int NORM_PRIORITY = 5;

3. 最低优先级：public final static int MIN_PRIORITY = 1;

设置优先级: public final void setPriority(int newPriority)

取得优先级: public final int getPriority()

main()主方法只是一个中等优先级

class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
                Thread.yield();
            System.out.println("当前线程：" + Thread.currentThread().getName() + "  i = " + i);
        }
    }
}

三、join()——等待该线程终止

等待该线程终止：当前线程等待别的线程执行完毕之后，再恢复执行。会释放对象锁。

使程序从：运行态——>阻塞态

class MyThread implements Runnable {
    @Override
    public void run() {
        try {
            System.out.println("主线程睡眠前的时间");
            Test.printTime();
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName());
            System.out.println("睡眠结束的时间");
            Test.printTime();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class Test {
    public static void main(String[] args) throws InterruptedException{
        MyThread mt = new MyThread();
        Thread thread = new Thread(mt,"子线程A");
        thread.start();
        System.out.println(Thread.currentThread().getName());
        thread.join();
        System.out.println("代码结束");
    }
    public static void printTime() {
        Date date=new Date();
        DateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time=format.format(date);
        System.out.println(time);
    }
}

四、wait()、notify()/notifyAll()——线程等待与唤醒

wait()方法就是使线程停止运行。

1. 方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法是用来将当前线程置入“预执行队列”中，并且在wait()所在的代码处停止执行，直到接到通知或被中断为止。

2. wait()方法只能在同步方法中或同步块中调用。如果调用wait()时，没有持有适当的锁，会抛出异常。

3. wait()方法执行后，当前线程释放锁，线程与其它线程竞争重新获取锁。

class MyThread implements Runnable{
    @Override
    public void run() {
    }
    public static void main(String[] args) throws InterruptedException {
        Object ob = new Object();
        synchronized (ob) {
          System.out.println("等待中...");
          ob.wait();
          System.out.println("等待结束...");
        }
    }
}

此时我们会发现，ob.wait() 就会一直等下去。这时我们就需要用到 notify() 方法来唤醒它。

notify() 方法就是使停止的线程继续运行。

1. 方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。如果有多个线程等待，则有线程规划器随机挑选出一个呈wait状态的线程。

2. 在notify() 方法后，当前线程不会马上释放该对象锁，要等到执行notify() 方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。

public class TestDemo {

    public static void main(String[] args) throws InterruptedException {
        final Object ob = new Object();
        //老师发试卷线程
        Thread test1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("老师发试卷");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (ob) {
                    System.out.println("老师：可以开始作答了");
                    ob.notify();
                }
            }
        });
        test1.start();
        //李雷作答线程
        Thread test2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (ob){
                    System.out.println("李雷：等待考试铃声...");
                    try{
                        ob.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }//进入阻塞状态，等待其他线程发通知
                    System.out.println("李雷：铃声响起，开始作答!");
                }
            }
        });
        test2.start();
        synchronized (ob){
            System.out.println("韩梅梅：等待考试铃声...");
            ob.wait();//进入阻塞状态，等待其他线程发通知
            System.out.println("韩梅梅：铃声响起，开始作答！");
            ob.notify();
        }
    }
}

notifyAll()一次唤醒所有的等待线程

以上notify() 方法只是唤醒某一个等待线程，如果有多个线程都在等待，这个时候就使用notifyAll() 方法可以一次唤醒所有的等待线程

五、interupt()——线程中断

interrupte()方法并不会立即执行中断操作：这个方法只会给线程设置一个为true的中断标志（中断标志只是一个布尔类型的变量），而设置之后，则根据线程当前的状态进行不同的后续操作。

如果在中断时，线程正处于非阻塞状态，则将中断标志修改为true,而在此基础上，一旦进入阻塞状态，则按照阻塞状态的情况来进行处理；例如，一个线程在运行状态中，其中断标志被设置为true之后，一旦线程调用了wait()、jion()、sleep()方法中的一种，立马抛出一个InterruptedException，且中断标志被程序会自动清除，重新设置为false。

public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    if (interrupted()) {
                        break;
                    }
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("非阻塞情况：" + Thread.currentThread().isInterrupted());
                }
            }
        });
        t1.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.interrupt();
    }

interrupt() 方法只是改变中断状态而已，它不会中断一个正在运行的线程。这一方法实际完成的是，给受阻塞的线程发出一个中断信号，这样受阻线程就得以退出阻塞的状态。

出现阻塞的情况主要有：

1. 线程调用 sleep方法,主动放弃占用的处理器资源。

2. 线程调用了阻塞式IO方法,在该方法返回前,该线程被阻塞。

3. 线程试图获得一个同步监视器,但该同步监视器正被其他线程所持有。

4. 线程等待某个通知。

5. 程序调用了 suspend方法将该线程挂起。此方法容易导致死锁,尽量避免使用该方法。