正文

java多线程系列---“基础篇”07之线程休眠

Hermioner  2022-04-17  435

关键词：

转自：http://www.cnblogs.com/skywang12345/p/3479256.html （含部分修改）

概要

本章，会对Thread中sleep()方法进行介绍。涉及到的内容包括：

sleep()介绍
sleep()示例
sleep() 与 wait()的比较

一. sleep()介绍

sleep() 定义在Thread.java中。
sleep() 的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待cpu的调度执行。

睡眠期间，该线程会让出CPU（但是不释放锁），但睡眠的时间不一定是确切的给定毫秒数，可能有一定的偏差，偏差与系统定时器和操作系统调度器的准确度和精度有关。

睡眠期间，线程可以被中断，如果被中断，sleep会抛出InterruptedException

二. sleep()示例

下面通过一个简单示例演示sleep()的用法。

// SleepTest.java的源码
class ThreadA extends Thread{
    public ThreadA(String name){ 
        super(name); 
    } 
    public synchronized void run() { 
        try {
            for(int i=0; i <10; i++){ 
                System.out.printf("%s: %d\n", this.getName(), i); 
                // i能被4整除时，休眠100毫秒
                if (i%4 == 0)
                    Thread.sleep(100);
            } 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    } 
} 

public class SleepTest{ 
    public static void main(String[] args){ 
        ThreadA t1 = new ThreadA("t1"); 
        t1.start(); 
    } 
}

运行结果：

t1: 0
t1: 1
t1: 2
t1: 3
t1: 4
t1: 5
t1: 6
t1: 7
t1: 8
t1: 9

结果说明：
程序比较简单，在主线程main中启动线程t1。t1启动之后，当t1中的计算i能被4整除时，t1会通过Thread.sleep(100)休眠100毫秒。

三. sleep() 与 wait()的比较

我们知道，wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时，也会释放同步锁。而sleep()的作用是也是让当前线程由“运行状态”进入到“休眠(阻塞)状态”。
但是，wait()会释放对象的同步锁，而sleep()则不会释放锁。
下面通过示例演示sleep()是不会释放锁的。

// SleepLockTest.java的源码
public class SleepLockTest{ 

    private static Object obj = new Object();

    public static void main(String[] args){ 
        ThreadA t1 = new ThreadA("t1"); 
        ThreadA t2 = new ThreadA("t2"); 
        t1.start(); 
        t2.start();
    } 

    static class ThreadA extends Thread{
        public ThreadA(String name){ 
            super(name); 
        } 
        public void run(){ 
            // 获取obj对象的同步锁
            synchronized (obj) {
                try {
                    for(int i=0; i <10; i++){ 
                        System.out.printf("%s: %d\n", this.getName(), i); 
                        // i能被4整除时，休眠100毫秒
                        if (i%4 == 0)
                            Thread.sleep(100);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } 
    } 
}

运行结果：(mynote:只有两种结果，要么t1先执行完，要么t2先执行完）

t1: 0
t1: 1
t1: 2
t1: 3
t1: 4
t1: 5
t1: 6
t1: 7
t1: 8
t1: 9
t2: 0
t2: 1
t2: 2
t2: 3
t2: 4
t2: 5
t2: 6
t2: 7
t2: 8
t2: 9

结果说明：
主线程main中启动了两个线程t1和t2。t1和t2在run()会引用同一个对象的同步锁，即synchronized(obj)。在t1运行过程中，虽然它会调用Thread.sleep(100)；但是，t2是不会获取cpu执行权的。因为，t1并没有释放“obj所持有的同步锁”！
注意，若我们注释掉synchronized (obj)后再次执行该程序，t1和t2是可以相互切换的。下面是注释调synchronized(obj) 之后的源码：

// SleepLockTest.java的源码(注释掉synchronized(obj))
public class SleepLockTest{ 

    private static Object obj = new Object();

    public static void main(String[] args){ 
        ThreadA t1 = new ThreadA("t1"); 
        ThreadA t2 = new ThreadA("t2"); 
        t1.start(); 
        t2.start();
    } 

    static class ThreadA extends Thread{
        public ThreadA(String name){ 
            super(name); 
        } 
        public void run(){ 
            // 获取obj对象的同步锁
//            synchronized (obj) {
                try {
                    for(int i=0; i <10; i++){ 
                        System.out.printf("%s: %d\n", this.getName(), i); 
                        // i能被4整除时，休眠100毫秒
                        if (i%4 == 0)
                            Thread.sleep(100);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
//            }
        } 
    } 
}

其中一种运行结果：

t1: 0
t2: 0
t1: 1
t1: 2
t2: 1
t2: 2
t2: 3
t2: 4
t1: 3
t1: 4
t2: 5
t2: 6
t1: 5
t1: 6
t1: 7
t1: 8
t2: 7
t2: 8
t1: 9
t2: 9

java多线程系列---“基础篇”05之线程等待与唤醒

转自：https://www.cnblogs.com/skywang12345/p/3479224.html （含部分修改）概要本章，会对线程等待/唤醒方法进行介绍。涉及到的内容包括：wait(),notify(),notifyAll()等方法介绍wait()和notify()wait(longtimeout)和notify()wait()和notifyAll()为什么not 查看详情

java多线程系列---“基础篇”10之线程优先级和守护线程

...https://www.cnblogs.com/weishao-lsv/p/8143976.html 在Java中有两类线程：UserThread(用户线程)、DaemonThread(守护线程)Java平台把操作系统的底层进行了屏蔽，在JVM虚拟平台里面构造出对自己有利的机制，这就是守护线程的由来。Daemon的作用是... 查看详情

java多线程系列---“基础篇”09之interrupt()和线程终止方式

...s.com/skywang12345/p/3479949.html（含部分修改）概要本章，会对线程的interrupt()中断和终止方式进行介绍。涉及到的内容包括：1.interrupt()说明2.终止线程的方式 2.1终止处于“阻塞状态”的线程 2.2终止处于“运行状态”... 查看详情

java多线程系列---“基础篇”08之join()

...一.join()介绍join()定义在Thread.java中。join()的作用：让“主线程”等待“ 查看详情

java多线程系列---“基础篇”04之synchronized关键字

转自：https://www.cnblogs.com/skywang12345/p/3479202.html （含部分修改）概要本章，会对synchronized关键字进行介绍。涉及到的内容包括：synchronized原理synchronized基本规则synchronized方法和synchronized代码块实例锁和全局锁一. synchron... 查看详情

java多线程系列---“基础篇”13之乐观锁与悲观锁

转自：http://www.cnblogs.com/zhengbin/p/5657435.html 乐观锁　　乐观锁(OptimisticLock),顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据... 查看详情

java多线程系列---“基础篇”14之wait,sleep,join,yield,park,unpark,notify等通信机制对比

1.线程让步：yield()yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保证在当前线程调用yield()之后，其它具有相同优先级的线程就一定... 查看详情

java多线程之基本概念

01. Java多线程系列--“基础篇”01之基本概念Java多线程学习（吐血超详细总结）查看详情

java多线程系列--“juc线程池”04之线程池原理

转自：http://www.cnblogs.com/skywang12345/p/3509960.html本章介绍线程池的生命周期。在"Java多线程系列--“基础篇”01之基本概念"中，我们介绍过，线程有5种状态：新建状态，就绪状态，运行状态，阻塞状态，死亡状态。线程池也有5种状... 查看详情

多线程（基础篇1）

　　在多线程这一系列文章中，我们将讲述C#语言中多线程的相关知识，在多线程（基础篇）中我们将学习以下知识点：创建线程中止线程线程等待终止线程确定线程的状态线程优先级前台线程和后台线程向线程传递参数使用C#... 查看详情

多线程（基础篇1）转载

在多线程这一系列文章中，我们将讲述C#语言中多线程的相关知识，在多线程（基础篇）中我们将学习以下知识点：创建线程中止线程线程等待终止线程确定线程的状态线程优先级前台线程和后台线程向线程传递参数使用C#的lock... 查看详情

java并发编程系列之一并发理论基础

...文章开始Java并发编程的进阶篇的学习，为了初学者对多线程的初步使用有基本概念和掌握，前置知识会对一些基础篇的内容进行介绍，以使初学者能够丝滑入戏。多线程学习，真正的难点不在于多线程程序的逻辑有多复杂，而... 查看详情

并发编程之多线程基础篇及面试

线程与进程区别每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级... 查看详情

java多线程系列--“juc线程池”02之线程池原理

...tps://www.cnblogs.com/skywang12345/p/3509941.html概要在上一章"Java多线程系列--“JUC线程池”01之线程池架构"中，我们了解了线程池的架构。线程池的实现类是ThreadPoolExecutor类。本章，我们通过分析ThreadPoolExecutor类，来了解线程池的原理。... 查看详情

java多线程编程（基础篇)

一.进程和线程的区别：进程：当前计算机正在运行的程序，进程是cpu分配资源的基本单位，一个进程至少有一个线程。线程：计算机中任务调度和最小的执行单元，一个线程也被称为轻量级进程。 ... 查看详情

java多线程系列--“juc线程池”03之线程池原理

...://www.cnblogs.com/skywang12345/p/3509954.html概要在前面一章"Java多线程系列--“JUC线程池”02之线程池原理(一)"中介绍了线程池的数据结构，本章会通过分析线程池的源码，对线程池进行说明。内容包括：线程池示例参考代码(基于JDK1.7.0_4... 查看详情

深入浅出多线程——线程基础篇

概述　　多线程是java编程中非常重要的一块，在多核CPU时代，多线程是最直接提高程序执行效率的途径。所以学好多线程对我们极其重要。Java多线程的基本应用　　创建多线程有两种方式：　　　　1，继承Thread类/***@authoritunic.... 查看详情

java多线程系列--“juc线程池”03之线程池原理

线程池示例在分析线程池之前，先看一个简单的线程池示例。importjava.util.concurrent.Executors;importjava.util.concurrent.ExecutorService;publicclassThreadPoolDemo1{publicstaticvoidmain(String[]args){//创建一个可重用固定线程数的线程池ExecutorServi 查看详情