为什么goroutine中的非缓冲通道会得到这样的顺序
goroutine中的非缓冲通道会得到顺序的原因是因为非缓冲通道的特性决定了它的发送和接收操作是同步的。
非缓冲通道是指在创建时没有指定容量的通道。它的特点是发送操作和接收操作必须同时准备好，才能进行通信。如果发送操作先执行，那么它会阻塞等待接收操作的准备；如果接收操作先执行，那么它会阻塞等待发送操作的准备。这种同步的特性保证了通信的顺序性。
具体来说，当一个goroutine向非缓冲通道发送数据时，如果没有其他goroutine正在等待接收数据，发送操作会被阻塞，直到有其他goroutine准备好接收数据。同样地，当一个goroutine从非缓冲通道接收数据时，如果没有其他goroutine正在等待发送数据，接收操作会被阻塞，直到有其他goroutine准备好发送数据。
这种同步的机制保证了非缓冲通道中的数据按照发送的顺序被接收。因为发送和接收操作必须配对进行，所以每个发送操作都会找到一个准备好接收的接收操作，从而保证了顺序性。
非缓冲通道的应用场景包括但不限于以下情况：
- 用于多个goroutine之间的同步和通信，确保数据按照特定的顺序进行处理。
- 用于控制并发执行的数量，限制同时执行的goroutine数量。
- 用于实现生产者-消费者模型，确保生产者和消费者之间的同步和顺序。
腾讯云提供了云计算相关的产品和服务，其中包括云服务器、云数据库、云存储、人工智能等。具体推荐的产品和产品介绍链接地址可以参考腾讯云官方网站：https://cloud.tencent.com/
相关·内容
我的代码如下：
package main
import (
"fmt"
)
func main() {
c1 := make(chan int)
fmt.Println("push c1: ")
c1 <- 10
g1 := <- c1
fmt.Println("get g1: ", g1)
}
当我使用delve进行调试时，它会输出以下结果：
push c1:
fatal error: all goroutines are asleep - deadlock!
goroutine
浏览 0提问于2019-01-12得票数 10
回答已采纳
我把我的问题归结为下面这个简单的例子。我正在调用一个接收两个通道并向每个通道发送一个消息的goroutine。然后，我正试图进一步接收这些信息。然而，接收渠道的顺序是重要的。如果我使用与发送消息相同的顺序，程序将运行。如果我换了它就不会了。
我原以为戈鲁蒂能独立运行，不需要检索消息，我就可以从我想要的任何频道接收到信息。
我可以通过发送消息给每个goroutine (2个goroutine)的单个通道来解决这个问题。
有人能解释为什么这里有秩序依赖，为什么两个独立的峡谷解决这种依赖吗？
package main
import "fmt"
func main() {
浏览 6提问于2022-02-22得票数 0
回答已采纳
1回答
如果我定义了一个没有缓冲区的通道，并将一个数据写入其中，它是立即阻塞(这样内核将寻找另一个未阻塞的goroutine，从该通道读取数据)，还是继续执行，并在下一次某些代码再次尝试写入通道时阻塞(当它还没有被读取时)？
下面是我用来研究这个问题的两段代码。
code1：
package main
import "fmt"
func main() {
c := make(chan int)
go func() {
for i := 0;i < 3; i++ {
c <- i
fmt.Pr
浏览 0提问于2019-06-21得票数 1
我不是100%清楚为什么我的代码不能工作 package main
import (
"fmt"
"sync"
)
//var wg sync.WaitGroup
func main() {
c := make(chan int)
send(c)
receive(c)
}
func send(c chan<- int) {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go
浏览 8提问于2021-04-29得票数 1
回答已采纳
我期望这段代码进入一个无限循环，发送和接收消息。但它似乎既不发送也不接收。为什么？
go func() {
for {
select {
case ch1 <- 1:
println("sent 1 ")
case c := <-ch1:
println(" received ", c)
}
time.Sleep(time.Second)
}
}()
浏览 2提问于2017-11-28得票数 3
回答已采纳
1回答
package main
import (
"fmt"
)
type A struct{
exit chan bool
}
func (a *A) f(){
select{
//the routine process
//quit
case <- a.exit:
fmt.Println("-----over-----")
a.exit <- true
fmt.Println(
浏览 3提问于2021-11-24得票数 0
回答已采纳
2回答
下面的代码会产生一个错误，为什么？
func main() {
messages := make(chan string)
messages <- "test" //line 16
fmt.Println(<-messages)
}
生成以下错误。
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/tmp/sandbox994400718/main.go:16 +0x80
一个值被发送到通道，并在下一
浏览 4提问于2015-11-08得票数 3
回答已采纳
2回答
环境: OS X 10.8，Go 1.0.2
我创建了一个缓冲区大小为2的通道，如果我写了三次通道，它会抛出错误：
所有的猩猩都睡着了-死锁！
当然，这是正确的。
但是如果我在峡谷中写了四次或更多次频道，它会很好，为什么？频道的容量是2，为什么goroutines忽略了这一点或者忘记了容量设置？我对读取通道代码进行评论，这样就没有人会读取信道并节省容量.我还使用time.Sleep来等待所有的猩猩完成他们的工作。
请查看以下代码:主包
//import "fmt"
func main() {
c := make(chan int, 2)
/*c <
浏览 1提问于2013-11-07得票数 2
回答已采纳
1回答
写到通道永远被阻塞
、、、
我被困在一种奇怪的情况下，对频道的写操作永远不会发生。
package main
import (
"fmt"
"time"
)
func main() {
c := make(chan int)
s := make(chan bool)
k := make(chan bool)
fmt.Println("start")
go func() {
fmt.Println("routine 1")
s <- true
}()
go
浏览 2提问于2017-01-21得票数 2
回答已采纳
这是我的全部围棋代码！令我困惑的是，case balances <- balance:并没有发生，我不知道为什么？
package main
import (
"fmt"
)
func main() {
done := make(chan int)
var balance int
balances := make(chan int)
balance = 1
go func() {
fmt.Println(<-balances)
done <- 1
}()
浏览 0提问于2021-11-04得票数 0
回答已采纳
1回答
这是怎么泄露出来的？
、、、
我试图理解这张幻灯片中概述的问题：
复制代码，以防URL死掉：
func sendMsg(msg, addr string) error {
conn, err := net.Dial("tcp", addr)
if err != nil {
return err
}
defer conn.Close()
_, err = fmt.Fprint(conn, msg)
return err
}
func broadcastMsg(msg string, addrs []string) error {
er
浏览 1提问于2013-08-01得票数 5
1回答
我最近开始学习Go，有一个案例告诉我，我不明白为什么他会根据一行中只打印第13行的更改而得到两种不同的行为，
在第一次运行时，我使用第13行运行程序，然后在主程序中，当我在第21行打印0的通道长度时，在接下来的一行中，它的打印2(我指的是主例程生成的第一个打印)。
在第二次运行中，我删除了第13行，然后在第一次打印的两次打印中，即通道的长度为2。
在图片中，您可以在控制台中看到两个不同的打印，我不明白它们为什么不同，仅仅是因为添加/删除第13行。
// Go behavior that I do not understand /:
package main
import "fmt&#
浏览 5提问于2022-05-22得票数 1
回答已采纳
我是个新手，我正在努力学习无缓冲的通道和goroutines。 我有这样的代码： func main() {
var waitGroup sync.WaitGroup
waitGroup.Add(3)
c := make(chan int)
go func() {
defer waitGroup.Done()
x := 1
res := x * 2
fmt.Println(x, "* 2 = ", res)
c <- x
}()
go func() {
defer waitGroup.Done()
x :
浏览 25提问于2020-12-30得票数 0
回答已采纳
2回答
通道并发问题
、、、
我正在尝试Go中的频道概念。我写了下面的程序playground来实现使用通道的计数器。但是我没有得到任何输出，尽管我在goroutine主体中进行了一些打印。 func main() {
wg := sync.WaitGroup{}
ch := make(chan int)
count := func(ch chan int) {
var last int
last = <-ch
last = last + 1
fmt.Println(last)
ch <- last
浏览 21提问于2019-04-16得票数 3
回答已采纳
我正在学习使用go构建web服务器的教程。
作者没有直接使用http.ListenAndServe()方法，而是创建了http.Server结构。
然后，他接着说：
创建用于侦听错误的缓冲通道
serverErrors := make(chan错误，1)
生成绑定到该通道的http侦听goroutine。
go func(){ fmt.Println(“开始.”)serverErrors <- api.ListenAndServe() }()
使用缓冲通道的原因是根据教练的说法。
这样，如果我们不收集这个错误，那么goroutine就可以退出。
在下面的程序中，确
浏览 1提问于2019-12-22得票数 4
回答已采纳
2回答
未知长度闭合通道
、、
我无法关闭频道时，不知道它的
长度
package main
import (
"fmt"
"time"
)
func gen(ch chan int) {
var i int
for {
time.Sleep(time.Millisecond * 10)
ch <- i
i++
// when no more data (e.g. from db, or event stream)
if i > 100 {
b
浏览 3提问于2015-12-15得票数 2
回答已采纳
我不明白为什么不能工作，但是这个可以工作。
正如我所理解的，goroutine异步地发送值true到a和12到b。在主函数中，a被阻塞，直到它接收到一个值。为什么当我重新排列它使b在a之前被阻塞时，它会导致死锁？
浏览 0提问于2019-01-24得票数 2
回答已采纳
我试图从循环中的goroutines收集错误，但不明白它如何正确地工作
func init() {
rand.Seed(1500929006430687579)
}
func goroutine(n int, wg *sync.WaitGroup, ch chan error) {
defer wg.Done()
defer fmt.Println("defer done")
fmt.Println("num ", n)
if n == 1 {
ch <- fmt.Errorf("erro
浏览 6提问于2022-11-11得票数 0
回答已采纳
我在试着理解go频道和go程序。为了做到这一点，我正在做在线练习。我在这里找到了一个：
我解决了第三个问题(名为“网吧”)。但是有些事情我是靠“运气”解决的，这让我很困扰，因为我不明白我的问题和为什么我的"hack“解决了它。
在下面的代码中，我将"enterChan <- next“替换为"go func() { enterChan <- next }()"，它解决了我的死锁。
谁能给我解释一下为什么它之前会死锁，为什么它会和这次黑客攻击一起工作？这是一个合适的解决方案，还是一个丑陋的解决方案？
请不要犹豫批评我的代码，我正在努力改进:)
非常感谢
浏览 2提问于2017-08-15得票数 1
下面是Donovan和Kernighan合著的“Go编程语言”一书中的示例代码。它是关于一个简单的并发网络爬虫。
当我把这个部分(放在main函数中)
seen := make(map[string]bool)
for list := range worklist {
for _, link := range list {
....
}
}
}
在前面
for i := 0; i < 20; i++ {
go func() {
for link := range unseenLinks {
浏览 2提问于2018-04-20得票数 0
2回答
我正在尝试使用Go的并发性来加速我的代码，
这就是我所拥有的：
for i:=7; i>-1; i-- {
go func (ch chan int32, ch2 chan int32, i int, arx int32, ary int32, dirf []int8, dirg []int8) {
nx := arx + int32(dirf[i])
ny := ary + int32(dirg[i])
ch &
浏览 0提问于2016-06-07得票数 0
3回答
当我在做一些go练习代码时，我遇到了一个问题，一个通道可能会像这样关闭两次：
// jobs.go
package main
import (
"fmt"
)
func main() {
fmt.Println("Hello, playground")
jobs := make(chan int, 5)
done := make(chan bool)
go func() {
for {
j,more := <-jobs
fmt.Println(&
浏览 0提问于2017-05-03得票数 2
回答已采纳
2回答
如何等待所有go例程完成，然后从通道中读取所有数据？
为什么这个例子在等待go例程结束时卡住了？
package main
import (
"fmt"
"sync"
"time"
)
func doStuff(i int, wg *sync.WaitGroup, messages chan<- string) {
defer wg.Done()
time.Sleep(time.Duration(i) * time.Second)
messages <- fmt.Sprintf(&
浏览 27提问于2020-02-11得票数 2
回答已采纳
1回答
我需要同时将大量数据从多个goroutines (比如30个)写入文本文件。我所做的是：
workers.Add(core.Concurrency)
for i := 0; i < core.Concurrency; i++ {
go func() {
defer workers.Done()
writer := bufio.NewWriter(f)
defer writer.Flush()
a.Worker(workChan, writer)
}()
浏览 26提问于2019-03-17得票数 0
回答已采纳
1回答
我一直在和玩，然后想出了：
type Function struct{
Function func(*TaskGroup, []interface{})
Args []interface{}
}
type TaskGroup struct{
Group sync.WaitGroup
Functions []Function
}
func (x *TaskGroup) Start() {
for _, Function := range x.Functions{
x.Group.Add(1)
go Function.Fu
浏览 4提问于2019-11-22得票数 0
回答已采纳
我遵循的是gorilla websocket库的聊天客户端/服务器示例。 https://github.com/gorilla/websocket/blob/master/examples/chat/hub.go#L36 我尝试修改代码，以便在新客户端连接时通知其他客户端，如下所示： for {
select {
case client := <-h.register:
h.clients[client] = true
// My addition. Hangs after this (no fu
浏览 37提问于2021-02-08得票数 0
回答已采纳
4回答
下面是一个关于未缓冲通道的简单示例代码：
ch01 := make(chan string)
go func() {
fmt.Println("We are in the sub goroutine")
fmt.Println(<-ch01)
}()
fmt.Println("We are in the main goroutine")
ch01 <- "Hello"
我得到的结果：
We are in the main goroutine
We are in the sub goroutine
Hello
去
浏览 1提问于2018-04-21得票数 4
回答已采纳
1回答
我知道我们可以从缓冲的关闭频道上读到。所以，我很有信心，我们也可以从没有缓冲。然而，我无法测试它。
func test(c chan int) {
time.Sleep(10 * time.Millisecond)
close(c)
fmt.Println(<-c)
}
func main() {
c := make(chan int)
go test(c)
c <- 5
}
输出
panic: send on closed channel
goroutine 1 [running]:
main.main()
/U
浏览 3提问于2022-04-01得票数 -2
对于Go中缓冲频道和非缓冲频道之间的区别，我有点困惑。例如，下面的代码执行得很好：
package main
import "fmt"
func main() {
messages := make(chan string)
go func() { messages <- "ping" }()
msg := <-messages
fmt.Println(msg)
}
另一方面，当我将"ping"传递给常规函数中的消息时，就会出现死锁。
package main
import "fmt"
浏览 1提问于2020-07-02得票数 2
回答已采纳
2回答
我有一个代码片段，我试图根据我如何放置close调用和位置来理解这些代码。
func main() {
ch := make(chan int, 2)
go func(ch chan int) {
for i := 1; i <= 5; i++ {
ch <- i
fmt.Println("Func goroutine sends data: ", i)
}
//Pos1 - Works perfectly
//close(ch)
浏览 0提问于2018-06-22得票数 1
回答已采纳
我读了Katherine Buday写的“Go中的并发性”一书，我不理解缓冲频道的例子的评论。
作者说：
if a goroutine making writes to a channel has knowledge of how many writes it will make,
it can be useful to create a buffered channel whose capacity is the number of writes to be made
这听起来很清楚，但例子令人困惑。
第一个示例：：
var stdoutBuff bytes.Buffer
浏览 2提问于2021-06-12得票数 1
回答已采纳
3回答
我正在尝试编写一个简单的Go脚本，它可以计算自然数之和，最大值为8：
package main
import "fmt"
func sum(nums []int, c chan int) {
var sum int = 0
for _, v := range nums {
sum += v
}
c <- sum
}
func main() {
allNums := []int{1, 2, 3, 4, 5, 6, 7, 8}
c1 := make(chan int)
c2 := make(
浏览 0提问于2012-12-27得票数 1
回答已采纳
package main
import (
"fmt"
"time"
)
func send(ch chan int, size int) {
for i := size; i < size+10; i++ {
ch <- i
fmt.Printf("put val %v in channel\n", i)
}
// close(ch)
}
func main() {
ch1 := make(chan int, 2)
ch2 := make(
浏览 0提问于2020-11-17得票数 0
2回答
我认为Go中的通道在默认情况下只保存1值，除非指定缓冲区大小。我读过那个。但当我运行这个：
func main (){
for i := range numGen(6) {
log.Println("taking from channel", i)
}
}
func numGen(num int) chan int {
c := make(chan string)
go func() {
for i := 0; i < num; i++ {
log.Println("pass
浏览 0提问于2017-06-13得票数 0
回答已采纳
我正在使用goroutines和channel编写一些golang并发代码，下面是我的代码：
package main
import "fmt"
func main() {
in := make(chan int)
go func() {
fmt.Println("Adding num to channel")
in <- 1
fmt.Println("Done")
}()
val := <- in
fmt.Println(val)
}
我创
浏览 12提问于2019-11-22得票数 0
回答已采纳
3回答
初级代码的死锁
、、
这是我的主要功能身体；
c := make(chan int)
go func() {
i := <-c
i++
time.Sleep(100 * time.Millisecond)
c <-i
}()
time.Sleep(1 * time.Second)
go func() {
i := <-c
i++
time.Sleep(100 * time.Millisecond)
c <-i
}()
time.Sleep(1 * time.Second)
fmt.Println(<-c)
浏览 1提问于2017-10-14得票数 0
回答已采纳
我有一个频道，接收器是主频道。我产生了多个goroutine，每个goroutine都通过通道发送一个字符串。 现在，这会导致死锁，因为我没有使用close函数正确地关闭通道。问题是，我不知道将创建多少goroutines，因此无法知道何时关闭通道。 我试过使用WaitGroup，问题是，我读到我不能在goroutine中使用Add，而我应该在主进程/ goroutine中使用wg.Add(1)，我尝试在父goroutine中使用Add来产生子goroutine，这也导致了死锁 package main import (
"fmt"
"sync"
浏览 15提问于2019-01-13得票数 2
回答已采纳
我正在尝试使用通道将数据传递到go例程和从go例程返回数据。在执行过程中的某个时刻，进程会冻结。我还不能通过Delve确定什么时候或者为什么。我到底做错了什么？
func handler(w http.ResponseWriter, r *http.Request) {
records := liaison.Parse(r) // Parse incoming JSON into a slice.
nRecords := len(records)
in, out := make(chan map[string]string), make(chan map[string]
浏览 1提问于2018-12-06得票数 0
我正在研究Go的一些并发模式。我查看了使用goroutines和输入/输出通道实现后台工作的方法，并注意到当我向接收通道发送新的作业(实质上是排队的新作业)时，我必须在goroutine中这样做，否则调度就会变得一团糟。意思：
这会崩溃：
for _, jobData := range(dataSet) {
input <- jobData
}
这样做是可行的：
go func() {
for _, jobData := range(dataSet) {
input <- jobData
}
}()
对于更具体的内容，我使用了一些无意义的代码
浏览 2提问于2014-03-24得票数 2
回答已采纳
3回答
我正在学习Go，并已经运行了以下代码片段：
package main
import "fmt"
func sum(a []int, c chan int) {
sum := 0
for _, v := range a {
sum += v
}
c <- sum // send sum to c
}
func main() {
a := []int{7, 2, 8, -9, 4, 0}
c := make(chan int, 2)
go sum(a[0:3], c)
go sum(a[3
浏览 0提问于2018-08-24得票数 4
回答已采纳
3回答
我需要定期刷新频道的内容。我用len()做了这件事，我想知道是否有更好的方法来做到这一点。
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
commch := make(chan int, 100)
go fillchan(commch)
drainchan(commch)
}
func fillchan(commch chan int) {
for {
select {
c
浏览 5提问于2013-06-24得票数 15
2回答
我在第30页上读到了和遭遇以及有趣的例子。
func sendMsg(msg, addr string) error {
conn, err := net.Dial("tcp", addr)
if err != nil {
return err
}
defer conn.Close()
_, err = fmt.Fprint(conn, msg)
return err
}
func broadcastMsg(msg string, addrs []string) error {
errc := make
浏览 2提问于2015-04-27得票数 5
回答已采纳
我的问题来自尝试读取一个通道，如果可以的话，使用一个select语句。
我知道像make(chan bool, 1)这样指定的通道会被缓冲，我的部分问题是，它和make(chan bool) -- 说的和make(chan bool, 0)是一样的东西--有什么区别?一个能容纳0值的通道有什么意义？
请参阅
chanFoo := make(chan bool)
for i := 0; i < 5; i++ {
select {
case <-chanFoo:
fmt.Println("Read")
case chanFoo
浏览 5提问于2013-11-18得票数 13
回答已采纳
有人能解释一下为什么第一段代码运行而第二段代码失败吗？
第一项：
func main() {
channel := make(chan int)
go demo(channel)
num := <-channel
println(num)
}
func demo(channel chan int) {
channel <- 2
}
第二项：
func main() {
demo()
}
func demo() {
channel := make(chan int)
channel <- 2
num := <-c
浏览 3提问于2022-01-06得票数 -3
回答已采纳
我试着通过运行小程序来学习频道。我不理解下面的程序，因为它给出了一个奇怪的输出：
func squares(c chan int) {
for i := 0; i < 4; i++ {
num := <-c
fmt.Println(num * num)
}
}
func main() {
c := make(chan int, 3)
go squares(c)
c <- 1
c <- 2
c <- 3
c <- 4
fmt.Println(runti
浏览 2提问于2020-09-07得票数 0
1回答
我是编程新手，我需要帮助。试着在戈朗上写gitlab刮刀。当我试图在多线程模式下获取有关项目的信息时，会出现一些问题。
以下是代码：
func (g *Gitlab) getAPIResponce(url string, structure interface{}) error {
responce, responce_error := http.Get(url)
if responce_error != nil {
return responce_error
}
ret, _ := ioutil.ReadAll(responce.Body)
浏览 2提问于2017-11-11得票数 1
回答已采纳
我试着理解当通道没有缓冲时所产生的错误：
“致命的错误:所有的猩猩都睡着了--死锁！”
package main
import "fmt"
func main() {
ch := make(chan int)
ch <- 1
gg := <-ch
fmt.Println(gg)
}
它在我缓冲通道ch := make(chan int, 2)之后才能工作。
浏览 0提问于2018-11-24得票数 1
2回答
我试着和go流一起工作，我有几个“愚蠢”的问题。
我用字节限制范围做了一个基本流示例，这是工作代码，下面是我的问题。
1-为什么这段代码在新行中显示1和2？为什么它不显示12在一个？第一批字节是否从字节限制流中删除？(但是，当我们已经将1数推入流中时，如何才能将2数推入流中呢？)我只是不明白
package main
import "fmt"
func main() {
ch := make(chan int, 2)
ch <- 1
ch <- 2
fmt.Println(<-ch)
fmt.Println(<
浏览 1提问于2017-10-09得票数 0
回答已采纳
我正在使用goroutines和channel编写一些golang并发代码，怀疑我的代码可能会导致goroutine泄漏。我的情况类似于下面的代码，或者您可以打开此。
func main() {
numCount := 3
numChan := make(chan int)
for i := 0; i < numCount; i++ {
go func(num int) {
fmt.Printf("Adding num: %d to chan\n", num)
numChan <
浏览 45提问于2019-05-29得票数 -1
回答已采纳
1回答
我看到一种恐慌
func main() {
ch := make(chan int)
ch <- 1
fmt.Println(<-ch)
}
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/tmp/sandbox058504389/main.go:10 +0x60
我相信，go检测到主例程在写入时被阻塞，并且由于在写入未缓冲的通道时出现了一个块，因此将永远无法到达读取片段，并且我们会看到恐慌。为什么我们在下面的代码中看
浏览 0提问于2018-07-26得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
