Java线程学习记录（六）——sleep

Sleep方法

作用： 只想让线程在预期的时间执行，其他时候不要占用CPU资源，直到下一次调起的时候才去占用CPU资源。
特点：

1. sleep方法不释放锁
2. 和wait不同，wait会让锁，但是sleep不会，在sleep期间谁都拿不走锁

线程sleep的时候不释放synchronized的monitor

public class SleepDontReleaseMonitor implements Runnable {
    public static void main(String[] args) {
        SleepDontReleaseMonitor sleepDontReleaseMonitor = new SleepDontReleaseMonitor();
        new Thread(sleepDontReleaseMonitor).start();
        new Thread(sleepDontReleaseMonitor).start();
    }

    @Override
    public void run() {
        syn();
    }

    private synchronized void syn() {
        System.out.println(Thread.currentThread().getName() + "获得到了monitor");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "退出了同步代码块");
    }
}

从输出中就可以看到，确实是需要等待sleep结束之后才会继续执行第二个线程

Thread-0获得到了monitor
Thread-0退出了同步代码块
Thread-1获得到了monitor
Thread-1退出了同步代码块

sleep不释放lock（lock需要手动释放）

public class SleepDontReleaseLock implements Runnable {

    // 独占锁
    private static final Lock lock = new ReentrantLock();

    @Override
    public void run() {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + "获得了锁");
        try {
            Thread.sleep(5000);
            System.out.println(Thread.currentThread().getName() + "已经释放了锁 ");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        SleepDontReleaseLock sleepDontReleaseLock = new SleepDontReleaseLock();
        new Thread(sleepDontReleaseLock).start();
        new Thread(sleepDontReleaseLock).start();

    }
}

从输出上看，线程也是必须等待sleep结束才会释放锁，其他线程才会获得锁。

Thread-0获得了锁
Thread-0已经释放了锁
Thread-1获得了锁
Thread-1已经释放了锁

sleep响应中断

每隔1秒输出当前时间，被中断，观察

public class SleepInterrupted implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(new Date());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                System.out.println("我被中断了！");
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new SleepInterrupted());
        thread.start();
        Thread.sleep(6500);
        thread.interrupt();
    }
}

输出

Thu May 21 21:19:12 CST 2020
Thu May 21 21:19:13 CST 2020
Thu May 21 21:19:14 CST 2020
Thu May 21 21:19:15 CST 2020
Thu May 21 21:19:16 CST 2020
Thu May 21 21:19:17 CST 2020
Thu May 21 21:19:18 CST 2020
我被中断了！
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at java.lang.Thread.sleep(Thread.java:340)
	at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
	at threadcoreknowledge.threadobjectclasscommonmethods.SleepInterrupted.run(SleepInterrupted.java:19)
	at java.lang.Thread.run(Thread.java:748)
Thu May 21 21:19:18 CST 2020
Thu May 21 21:19:19 CST 2020
Thu May 21 21:19:20 CST 2020

从输出里是可以明显的看到被中断时候抛出的异常
这里推荐使用**TimeUnit.SECONDS.sleep(1);**方式，因为在生产环境的时候可能会出现如3小时24分50秒的情况，如果用Thead.sleep()，这里是需要传毫秒的，我们还需要对时间进行转换，如果采用推荐的方式那么就简介，明了。并且在Thread.sleep()方法如果参数小于0是会抛出异常，而第一种方法则会直接忽略。

TimeUnit.HOURS.sleep(3);
TimeUnit.MINUTES.sleep(24);
TimeUnit.SECONDS.sleep(1);

总结

sleep方法可以让线程进入Waiting状态，并且不占用CPU资源，但是不释放锁，直到规定时间后在执行，休眠期间如果被中断，会抛出异常并且清除中断状态。

wait/notify、sleep异同

相同

1. 阻塞（对象状态是Waiting、TimeWaiting）；
2. 响应中断（在休眠期间都会响应中断）。

不同点

1. wait/notify需要放到同步代码块中，sleep不需要。wait/notify是需要相互配合的，线程更安全，防止死锁和永久等待；
2. wait/notify会释放锁，sleep不会；
3. 指定时间（参数不同），wait可以不指定时间，直到被唤醒；sleep必须要指定直接；
4. 所属类不同，wait/notify属于Object，因为java的设计中，每一个对象都是一把锁，sleep属于Thread。