多线程中sleep方法，简单介绍。

一 是什么？

package com.aaa.threaddemo;
/*
 * 多线程中的sleep方法？ 
 *         sleep 隶属于Thread的方法，顾名思义，让线程睡一会。
             1 public static native void sleep(long millis) throws InterruptedException; 使用需要try catch，或者  声明一个异常，才能使用。
             2    long 跟的时间单位是秒          
             3    会让线程进入阻塞状态
             4 调用线程会【暂时让出指定时间】的执行权。让出CPU，但是监控状态依然保持着。
             5 线程不会释放对象锁。
             6 如果在睡眠期间其他线程调用了该线程的interrupt（）方法中断了该线程，则该线程会在调用sleep方法的地方抛出InterruptedException异常而返回。
 */
public class ThreadRun {
    public static void main(String[] args) throws InterruptedException {
        Thread1 thread1 = new Thread1();
        thread1.start();
        //在thread1 阻塞的情况下，让其中断，会抛出异常          java.lang.InterruptedException
        thread1.interrupt();        
    }
}

class Thread1 extends Thread{
    @Override
    public void run() {    
        try {
            System.out.println("1111");        
            // 让子线程休息一秒， 在一秒内线程让出CPU，此时thread1 进入阻塞状态。
            // 一秒后函数正常返回，参与CPU的调度。获取到CPU资源进入到运行状态。
            Thread1.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

二 验证sleep，监控状态依然保持。      原文 https://zhuanlan.zhihu.com/p/259158177

package com.aaa.threaddemo;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
 * 多线程中的sleep方法？ 
 *         sleep 隶属于Thread的方法，顾名思义，让线程睡一会。
             1 public static native void sleep(long millis) throws InterruptedException; 使用需要try catch，或者  声明一个异常，才能使用。
             2    long 跟的时间单位是秒          
             3    会让线程进入阻塞状态
             4 调用线程会【暂时让出指定时间】的执行权。让出CPU，但是监控状态依然保持着。
             5 线程不会释放对象锁。
             6 如果在睡眠期间其他线程调用了该线程的interrupt（）方法中断了该线程，则该线程会在调用sleep方法的地方抛出InterruptedException异常而返回。
 */
public class ThreadRun {
    private static ReentrantLock lock = new ReentrantLock();
    
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 =  new Thread(new Runnable() {
            public void run() {
                //创建独占锁   
                lock.lock();
                try {
                    System.out.println("线程1开始睡觉");    
                    Thread.sleep(1000);
                    System.out.println("线程1结束睡觉");    
                    
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //解除锁
                    lock.unlock();
                }    
            }
        });
        
        Thread thread2 =  new Thread(new Runnable() {
            public void run() {
                //创建独占锁
                lock.lock();
                try {
                    System.out.println("线程2开始睡觉");    
                    Thread.sleep(2000);
                    System.out.println("线程2结束睡觉");    
                    
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }
        });
        
        
        thread1.start();
        thread2.start();
    }
}