介绍程序中thread.sleep()的作用,作者写的相当的通俗易懂,

本文深入探讨了Thread.Sleep函数的用法及其对线程控制的影响,解释了操作系统的两种调度策略:时间片算法和抢占式算法。通过类比分蛋糕场景,详细阐述了两种算法的工作原理,并对比了Thread.Sleep(0)函数的作用,强调了它如何触发CPU竞争,从而避免程序假死现象。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

我们可能经常会用到 Thread.Sleep 函数来使线程挂起一段时间。那么你有没有正确的理解这个函数的用法呢?思考下面这两个问题:

假设现在是 2008-4-7 12:00:00.000,如果我调用一下 Thread.Sleep(1000) ,在 2008-4-7 12:00:01.000 的时候,这个线程会 不会被唤醒?某人的代码中用了一句看似莫明其妙的话:Thread.Sleep(0) 。既然是 Sleep 0 毫秒,那么他跟去掉这句代码相比,有啥区别么?

我们先回顾一下操作系统原理。

操作系统中,CPU竞争有很多种策略。Unix系统使用的是时间片算法,而Windows则属于抢占式的。

在时间片算法中,所有的进程排成一个队列。操作系统按照他们的顺序,给每个进程分配一段时间,即该进程 允许运行的时间。如果在 时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束,则CPU当即进行切换。调度程 序所要做的就是维护一张就绪进程列表,,当进程用完它的时间片后,它被移到队列的末尾。

所谓抢占式操作系统,就是说如果一个进程得到了 CPU 时间,除非它自己放弃使用 CPU ,否则将完全霸占 CPU 。因此可以看出,在抢 占式操作系统中,操作系统假设所有的进程都是“人品很好”的,会主动退出 CPU 。

在抢占式操作系统中,假设有若干进程,操作系统会根据他们的优先级、饥饿时间(已经多长时间没有使用过 CPU 了),给他们算出一 个总的优先级来。操作系统就会把 CPU 交给总优先级最高的这个进程。当进程执行完毕或者自己主动挂起后,操作系统就会重新计算一 次所有进程的总优先级,然后再挑一个优先级最高的把 CPU 控制权交给他。

我们用分蛋糕的场景来描述这两种算法。假设有源源不断的蛋糕(源源不断的时间),一副刀叉(一个CPU),10个等待吃蛋糕的人(10 个进程)。

如果是 Unix操作系统来负责分蛋糕,那么他会这样定规矩:每个人上来吃 1 分钟,时间到了换下一个。最后一个人吃完了就再从头开始。于是,不管这10个人是不是优先级不同、饥饿程度不同、饭量不同,每个人上来的时候都可以吃 1 分钟。当然,如果有人本来不太饿,或者饭量小,吃了30秒钟之后就吃饱了,那么他可以跟操作系统说:我已经吃饱了(挂起)。于是操作系统就会让下一个人接 着来。

如果是 Windows 操作系统来负责分蛋糕的,那么场面就很有意思了。他会这样定规矩:我会根据你们的优先级、饥饿程度去给你们每个人计算一个优先级。优先级最高的那个人,可 以上来吃蛋糕——吃到你不想吃为止。等这个人吃完了,我再重新根据优先级、饥饿程度来计算每个人的优先级,然后再分给优先级最高的那个人。

这样看来,这个场面就有意思了——可能有些人是PPMM,因此具有高优先级,于是她就可以经常来吃蛋 糕。可能另外一个人是个丑男,而去很ws,所以优先级特别低,于是好半天了才轮到他一次(因为随着时间的推移,他会越来越饥饿,因此算出来的总优先级就会 越来越高,因此总有一天会轮到他的)。而且,如果一不小心让一个大胖子得到了刀叉,因为他饭量大,可能他会霸占着蛋糕连续吃很久很久,导致旁边的人在那里 咽口水。。。
而且,还可能会有这种情况出现:操作系统现在计算出来的结果,5号PPMM总优先级最高,而且高出别人一大截。因此就叫5号来吃蛋 糕。5号吃了一小会儿,觉得没那么饿了,于是说“我不吃了”(挂起)。因此操作系统就会重新计算所有人的优先级。因为5号刚刚吃过,因此她的饥饿程度变小 了,于是总优先级变小了;而其他人因为多等了一会儿,饥饿程度都变大了,所以总优先级也变大了。不过这时候仍然有可能5号的优先级比别的都高,只不过现在 只比其他的高一点点——但她仍然是总优先级最高的啊。因此操作系统就会说:5号mm上来吃蛋糕……(5号mm心里郁闷,这不刚吃过嘛……人家要减肥……谁 叫你长那么漂亮,获得了那么高的优先级)。

那么,Thread.Sleep 函数是干吗的呢?还用刚才的分蛋糕的场景来描述。上面的场景里面,5号MM在吃了一次蛋糕之后,觉得已经有8分饱了,她觉得在未来的半个小时之内都不想再 来吃蛋糕了,那么她就会跟操作系统说:在未来的半个小时之内不要再叫我上来吃蛋糕了。这样,操作系统在随后的半个小时里面重新计算所有人总优先级的时候, 就会忽略5号mm。Sleep函数就是干这事的,他告诉操作系统“在未来的多少毫秒内我不参与CPU竞争”。

看完了 Thread.Sleep 的作用,我们再来想想文章开头的两个问题。

对于第一个问题,答案是:不一定。因为你只是告诉操作系统:在未来的1000毫秒内我不想再参与到 CPU竞争。那么1000毫秒过去之后,这时候也许另外一个线程正在使用CPU,那么这时候操作系统是不会重新分配CPU的,直到那个线程挂起或结束;况 且,即使这个时候恰巧轮到操作系统进行CPU 分配,那么当前线程也不一定就是总优先级最高的那个,CPU还是可能被其他线程抢占去。

与此相似的,Thread有个Resume函数,是用来唤醒挂起的线程的。好像上面所说的一样,这个函数只是“告诉操作系统我从现在起开始参与CPU竞争了”,这个函数的调用并不能马上使得这个线程获得CPU控制权。

对于第二个问题,答案是:有,而且区别很明显。假设我们刚才的分蛋糕场景里面,有另外一个PPMM 7号,她的优先级也非常非常高(因为非常非常漂亮),所以操作系统总是会叫道她来吃蛋糕。而且,7号也非常喜欢吃蛋糕,而且饭量也很大。不过,7号人品很 好,她很善良,她没吃几口就会想:如果现在有别人比我更需要吃蛋糕,那么我就让给他。因此,她可以每吃几口就跟操作系统说:我们来重新计算一下所有人的总 优先级吧。不过,操作系统不接受这个建议——因为操作系统不提供这个接口。于是7号mm就换了个说法:“在未来的0毫秒之内不要再叫我上来吃蛋糕了”。这 个指令操作系统是接受的,于是此时操作系统就会重新计算大家的总优先级——注意这个时候是连7号一起计算的,因为“0毫秒已经过去了”嘛。因此如果没有比 7号更需要吃蛋糕的人出现,那么下一次7号还是会被叫上来吃蛋糕。

因此,Thread.Sleep(0)的作用,就是“触发操作系统立刻重新进行一次CPU竞争”。竞争 的结果也许是当前线程仍然获得CPU控制权,也许会换成别的线程获得CPU控制权。这也是我们在大循环里面经常会写一句Thread.Sleep(0) ,因为这样就给了其他线程比如Paint线程获得CPU控制权的权力,这样界面就不会假死在那里。

末了说明一下,虽然上面提到说“除非它自己放弃使用 CPU ,否则将完全霸占 CPU”,但这个行为仍然是受到制约的——操作系统会监控你霸占CPU的情况,如果发现某个线程长时间霸占CPU,会强制使这个线程挂起,因此在实际上不 会出现“一个线程一直霸占着 CPU 不放”的情况。至于我们的大循环造成程序假死,并不是因为这个线程一直在霸占着CPU。实际上在这段时间操作系统已经进行过多次CPU竞争了,只不过其他 线程在获得CPU控制权之后很短时间内马上就退出了,于是就又轮到了这个线程继续执行循环,于是就又用了很久才被操作系统强制挂起。。。因此反应到界面 上,看起来就好像这个线程一直在霸占着CPU一样。

末了再说明一下,文中线程、进程有点混乱,其实在Windows原理层面,CPU竞争都是线程级的,本文中把这里的进程、线程看成同一个东西就好了。

<think>首先,用户的问题是关于Java中异步编程的基本概念和使用示例。用户希望得到一个通俗的解释和示例。 根据系统级指令: - 所有行内数学表达式必须使用$...$格式。 - 独立公式必须使用$$...$$格式并单独成段。 - 使用中文回答。 - 生成相关问题。 - 回答中引用的段落末尾自然地添加引用标识。 - 回答结构清晰,帮助用户逐步解决问题。 - 参考站内引用:用户提供了三个引用,但它们似乎与异步编程相关,但不是直接针对用户的问题。用户说:“上述引用仅供参考”,所以我需要基于用户的问题来回答,而不是依赖这些引用。 用户的问题是:“我想希望了解Java中异步编程的基本概念及其使用方式 请问Java 异步编程通俗解释以及使用示例” 所以,我的回答应该包括: 1. 通俗解释Java异步编程的概念。 2. 使用示例。 3. 结构清晰,逐步解释。 4. 生成相关问题。 5. 在回答中,如果引用段落,添加引用标识,但用户提供的引用可能不直接相关,所以我应该基于自己的知识回答,除非必要。 关键点: - 异步编程:在Java中,异步编程允许程序在等待某些操作(如I/O操作)完成时继续执行其他任务,而不是阻塞等待。这提高了性能和响应性。 - 基本概念:非阻塞、回调、Future、CompletableFuture等。 - 使用示例:提供简单的代码示例,比如使用CompletableFuture或@Async注解。 参考用户提供的引用: - 引用[1]:关于Spring框架中的异步编程,提到@Async注解和CompletableFuture。 - 引用[2]:关于Callback模式。 - 引用[3]:关于CompletableFuture的使用。 所以,我可以整合这些概念来回答。 回答结构: 1. **介绍异步编程**:用通俗易懂的语言解释。 2. **基本概念**:解释关键术语。 3. **使用方式**:提供示例代码。 4. **总结**:简要回顾。 5. **相关问题**:生成几个相关问题。 生成相关问题:指令要求“生成相关问题”,所以我需要在回答结束后添加§§相关问题§§部分。 语言:全程使用中文。 代码示例:使用代码块格式,就像示例中那样。 引用标识:如果我在回答中引用用户提供的引用内容,添加引用标识如[^1]。但用户说这些引用仅供参考,所以我应该避免直接复制,而是基于它们解释。例如,提到CompletableFuture时,可以引用[^3]。 现在,规划回答: - **开头**:直接回答问题。 - **解释概念**:用生活比喻,比如引用[1]中的“外卖取餐”场景。 - **关键概念**: - 同步 vs 异步。 - Java中的工具:Callable、Future、CompletableFuture、@Async等。 - **示例**:提供一个简单的CompletableFuture示例或@Async示例。 - **相关问题**:如“异步编程的优缺点?”、“如何在Spring中使用异步?”等。 最终回答格式: - 回答主体。 - 代码块(如果适用)。 - §§相关问题§§。</think>### Java 异步编程通俗解释及使用示例 Java 异步编程是一种编程范式,允许程序在执行耗时操作(如网络请求、文件读或数据库查询)时,不阻塞主线程,而是继续执行其他任务。当耗时操作完成后,程序通过回调或通知机制处理结果。这类似于生活中的“点外卖”:你下单后不需要在餐厅门口干等,而是可以去干别的事;当外卖送到时,你会收到通知去取餐[^1]。这种方式能显著提升程序的性能和响应速度,尤其在高并发场景中。 #### 基本概念 - **同步编程**:程序按顺序执行任务,必须等待当前任务完成才能执行下一个任务(如排队点餐)。 - **异步编程**:程序启动一个任务后立即返回,不等待结果;任务在后台执行,完成后通过回调函数或 Future 对象通知主线程(如点外卖后继续工作)。 - **关键组件**: - **Future 和 CompletableFuture**:Java 提供的工具,用于表示异步操作的结果。CompletableFuture 更强大,支持链式调用和异常处理[^3]。 - **Callback 模式**:通过回调函数(如接口实现)处理异步结果,避免阻塞[^2]。 - **@Async 注解**:在 Spring 框架中,使用 `@Async` 标记方法为异步,简化实现[^1]。 异步编程的核心优势是“让程序不等”,提升系统吞吐量,但需注意线程管理和异常处理[^3]。 #### 使用示例 下面以 Java 中的 `CompletableFuture` 为例,展示一个简单的异步编程示例。场景:模拟一个耗时操作(如调用远程API),主线程在等待期间执行其他任务。 ```java import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; public class AsyncExample { public static void main(String[] args) { // 启动异步任务:模拟耗时操作(如调用API) CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> { try { Thread.sleep(2000); // 模拟2秒耗时操作 } catch (InterruptedException e) { e.printStackTrace(); } return "异步任务完成!结果:数据加载成功"; }); // 主线程继续执行其他任务,不阻塞 System.out.println("主线程:正在执行其他任务..."); // 处理异步结果(使用回调) future.thenAccept(result -> System.out.println("回调处理:" + result)); // 主线程等待异步任务结束(可选,实际中通常不阻塞) try { future.get(); // 获取结果,如果异步任务未完成,会阻塞等待 } catch (InterruptedException | ExecutionException e) { System.err.println("异常处理:" + e.getMessage()); } System.out.println("主线程:所有任务结束"); } } ``` **代码解释**: 1. **异步任务启动**:`CompletableFuture.supplyAsync()` 启动一个后台线程执行耗时操作(这里用 `Thread.sleep` 模拟)。 2. **非阻塞执行**:主线程立即打印“主线程:正在执行其他任务...”,不等待异步任务。 3. **回调处理**:`thenAccept` 方法注册一个回调函数,当异步任务完成时自动执行,打印结果。 4. **异常处理**:`future.get()` 会阻塞等待结果,但实际中应避免阻塞;更好的做法是用 `exceptionally` 处理异常[^3]。 - 运行输出示例: ``` 主线程:正在执行其他任务... 回调处理:异步任务完成!结果:数据加载成功 主线程:所有任务结束 ``` **Spring 框架中的简化示例(使用 @Async)** 在 Spring Boot 项目中,通过 `@Async` 注解更易实现异步: ```java import org.springframework.scheduling.annotation.Async; import org.springframework.scheduling.annotation.EnableAsync; import org.springframework.stereotype.Service; @Service @EnableAsync public class AsyncService { @Async public CompletableFuture<String> fetchData() { // 模拟耗时操作 try { Thread.sleep(2000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } return CompletableFuture.completedFuture("数据加载完成"); } } // 在Controller中调用 @RestController public class MyController { @Autowired private AsyncService asyncService; @GetMapping("/data") public String getData() { asyncService.fetchData().thenAccept(result -> System.out.println("处理结果: " + result)); return "请求已接收,正在异步处理..."; } } ``` - **说明**:`@Async` 标记的方法会在独立线程运行;调用 `fetchData()` 后立即返回,前端收到“请求已接收”响应,而结果在后台处理[^1]。 #### 总结 Java 异步编程通过非阻塞机制提升效率,核心工具包括 `CompletableFuture` 和 Spring 的 `@Async`。使用时注意: - 避免主线程阻塞(如少用 `get()` 方法)。 - 使用回调或 `exceptionally` 处理异常[^3]。 - 在 I/O 密集型应用(如 Web 服务)中效果显著。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值