blocks|key|2655503|text|如果删除time.Sleep，就不会给say("world")+goroutine一个运行的机会。goroutine调度程序不是抢占性的。你的猩猩必须放弃控制，否则另一个峡谷将运行。放弃控制的一种方法是运行time.Sleep。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2655504|如果您从time.Sleep函数中取出say，那么主goroutine运行5次，而不放弃对次要goroutine的控制，然后当主goroutine从say返回时，程序退出，因为没有什么可以使程序存活。|2655505|entityMap^0|4|A|J|C|2V|A|0|4|A|J|3|22|3|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|I|$]]

If you remove the <code>time.Sleep</code> you don't give the <code>say("world")</code> goroutine a chance to run. The goroutine scheduler is not preemptive. Your goroutines have to give up control before another goroutine will run. One way to give up control is to run <code>time.Sleep</code>.

If you take out the <code>time.Sleep</code> from the <code>say</code> function then the primary goroutine runs 5 times without giving up control to the secondary goroutine and then when the primary goroutine returns from <code>say</code> the program exits because there is nothing to keep the program alive.

blocks|key|2655543|text|因为goroutine调度程序不是先发制人的，所以在另一个goroutine运行之前，您的goroutines必须放弃控制。放弃控制的一种方法是使用time.Sleep。另一种方法是使用runtime.Gosched()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2655544|下面是修改后的教程，以使用戈斯普特()：http://play.golang.org/p/jQ9mlGYXXE|2655545|这是理解猩猩的有用的一课。然而，试图直接控制调度程序肯定是一种反模式；悲伤往往会随之而来。|2655546|相反，要更多地考虑像通信数字硬件这样的大杂烩(状态机是一个很好的类比)。更好的方法是了解通信顺序过程模型，它是goroutines的基础。在基于CSP的设计中，每个goroutine都有自己的私有状态，并交换消息以与其他goroutines状态交互。消息的传递强制同步，调度程序使用同步来确定哪些活动获得cpu时间，哪些活动被放入等待队列。|2655547|当您接近这种方式时，您可能根本不需要担心调度程序内部的问题。|2655548|entityMap|0|LINK|mutability|MUTABLE|url|http://play.golang.org/p/jQ9mlGYXXE|1|http://usingcsp.com/^0|22|A|2L|H|0|K|Z|0|0|0|18|6|1|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@]|D|@$9|13|A|14|1|15]]|E|$]]|$1|H|3|I|5|6|7|16|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|17|8|@]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|L|3|M|5|6|7|1B|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]|V|$5|Q|R|S|E|$T|W]]]]

Because the goroutine scheduler is not preemptive, your goroutines have to give up control before another goroutine will run. One way to give up control is with <code>time.Sleep</code>. Another way is with <code>runtime.Gosched()</code>.

Here's the tutorial modified to use Gosched(): <a href="http://play.golang.org/p/jQ9mlGYXXE" rel="noreferrer">http://play.golang.org/p/jQ9mlGYXXE</a>

This is a useful lesson in understanding goroutines. However, trying to control the scheduler directly is definitely an anti-pattern; grief will often follow.

Instead, think more about the goroutines like chunks of communicating digital hardware (state machines are a good analogy). It's better to learn about the <a href="http://usingcsp.com/" rel="noreferrer">Communicating Sequential Processes</a> model on which goroutines are based. In a CSP-based design, each goroutine has its own private state and exchanges messages to interact with the state of other goroutines. The passing of messages forces synchronization, which the scheduler uses to determine what activity gets cpu time and what gets put in a wait queue.

When you approach Go this way, you probably never need to worry about scheduler internals.

blocks|key|544936|text|如果从say函数中删除time.Sleep，则main将执行say("hello")并在不执行goroutine的情况下终止。如果在主端之前添加time.Sleep+(或其他情况下为select+{})，则会给goroutine提供运行时间，并且将从调度程序中选择该线程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|544937|示例：|544938|package+main

import+(
++++"fmt"
++++"time"
)

func+say(s+string)+{
++++for+i+:=+0;+i+<+5;+i%2B%2B+{
++++++++//+time.Sleep(100+*+time.Millisecond)
++++++++fmt.Println(s)
++++}
}

func+main()+{
++++go+say("world")
++++say("hello")

++++time.Sleep(1*time.Second)
++++//+Vs:+
++++//+select+{}+//+blocks+indefinitely,+requires+manual+interrupt
++++++++++//+In+CSP-speak+the+empty+select+is+like+STOP.
++++++++++//+for{}+would+cause+the+cpu+to+max+and+the+process's+STATE+will+be+`running`
++++++++++//+select{}+will+not+cause+the+cpu+to+max+and+the+process+state+will+be+`sleeping`
}|code-block|syntax|javascript|544939|输出通常是5+hello，后面是5+world，但它也可以在最后一次hello之前打印出其中的一个世界。|544940|->+(http://)+goo.gl/K2v7H0+)|544941|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you remove time.Sleep from the say function the main will execute say("hello") and terminate without executing the goroutine. If you add a time.Sleep (or otherwise a select {}) before the main end it will give time to the goroutine to run and that thread will be picked from the scheduler.

Example:

<pre><code>package main

import (
 "fmt"
 "time"
)

func say(s string) {
 for i := 0; i &lt; 5; i++ {
 // time.Sleep(100 * time.Millisecond)
 fmt.Println(s)
 }
}

func main() {
 go say("world")
 say("hello")

 time.Sleep(1*time.Second)
 // Vs: 
 // select {} // blocks indefinitely, requires manual interrupt
 // In CSP-speak the empty select is like STOP.
 // for{} would cause the cpu to max and the process's STATE will be `running`
 // select{} will not cause the cpu to max and the process state will be `sleeping`
}
</code></pre>

The output will usually be 5 hello followed by 5 world but it could also manage to print one of the world before the last hello

TRY IT --> (http://) goo.gl/K2v7H0

In the GO tutorial, we have this slide: <a href="https://tour.golang.org/concurrency/1" rel="noreferrer">Goroutines</a>

<pre><code>package main

import (
 "fmt"
 "time"
)

func say(s string) {
 for i := 0; i &lt; 5; i++ {
 time.Sleep(100 * time.Millisecond)
 fmt.Println(s)
 }
}

func main() {
 go say("world")
 say("hello")
}
</code></pre>

Running this code produces expected results ("world" and "hello" written to the screen interchangeably 5 times).

However, if we comment out <code>time.Sleep</code> (and consequently, the <code>"time"</code> line of the import) and run the program again, we are left with only "hello" written to the screen five times.

What is so important about <code>time.Sleep</code> that saves the goroutine from dying?

Why is time.sleep required to run certain goroutines?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在GO教程中，我们有以下幻灯片：package mainimport ( "fmt" "time")func say(s string) { for i := 0; i < 5; i++ { time.Sleep(100 * time.Millisecond) fmt.Pr...

问为什么time.sleep需要运行特定的峡谷呢？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么time.sleep需要运行特定的峡谷呢？EN