如何在不等待另一个goroutine设置的情况下读取通道？
在不等待另一个goroutine设置的情况下读取通道，可以通过使用select语句结合default分支来实现非阻塞读取。select语句用于在多个通道操作中进行选择，而default分支则表示当没有任何通道操作准备就绪时，可以执行的默认操作。
下面是一个示例代码：
select {
case data := <-channel:
// 读取通道数据
fmt.Println(data)
default:
// 没有数据可读取时执行的操作
fmt.Println("No data available")
}在上述代码中，select语句会尝试从通道中读取数据。如果通道中有数据可读取，就会执行对应的case语句。如果通道中没有数据可读取，就会执行default分支中的操作。
需要注意的是，如果通道中没有数据可读取，select语句会立即执行default分支，而不会等待其他goroutine设置通道的值。这样就实现了在不等待另一个goroutine设置的情况下读取通道的目的。
这种非阻塞读取通道的方式适用于需要及时响应的场景，例如在定时任务中检查通道是否有新的数据到达，或者在并发编程中处理多个通道的数据。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云容器服务 TKE：腾讯云容器服务是一种高度可扩展的容器管理服务，支持容器化应用的部署、运行和管理。
- 腾讯云函数计算 SCF：腾讯云函数计算是一种事件驱动的无服务器计算服务，可帮助开发者更轻松地构建和运行云端应用程序。
- 腾讯云消息队列 CMQ：腾讯云消息队列是一种高可靠、高可用的消息队列服务，可实现分布式系统之间的异步通信。
- 腾讯云云数据库 CDB：腾讯云云数据库是一种高性能、可扩展的云数据库服务，支持多种数据库引擎，如MySQL、Redis等。
- 腾讯云负载均衡 CLB：腾讯云负载均衡是一种流量分发的网络设备，可将访问流量按一定规则分发到多个后端服务器上，提高系统的可用性和负载能力。
- 腾讯云安全组：腾讯云安全组是一种虚拟防火墙，用于设置云服务器的网络访问控制规则，保护云服务器的网络安全。
- 腾讯云直播：腾讯云直播是一种实时音视频云服务，提供直播推流、直播播放、直播录制等功能，适用于在线教育、游戏直播等场景。
请注意，以上仅为示例产品，具体选择适合的产品需根据实际需求进行评估。
相关·内容
我不是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
回答已采纳
我把我的问题归结为下面这个简单的例子。我正在调用一个接收两个通道并向每个通道发送一个消息的goroutine。然后，我正试图进一步接收这些信息。然而，接收渠道的顺序是重要的。如果我使用与发送消息相同的顺序，程序将运行。如果我换了它就不会了。
我原以为戈鲁蒂能独立运行，不需要检索消息，我就可以从我想要的任何频道接收到信息。
我可以通过发送消息给每个goroutine (2个goroutine)的单个通道来解决这个问题。
有人能解释为什么这里有秩序依赖，为什么两个独立的峡谷解决这种依赖吗？
package main
import "fmt"
func main() {
浏览 6提问于2022-02-22得票数 0
回答已采纳
Go RunTime写入管道，然后不关闭管道，然后正常执行。 通道未关闭时，为什么没有死锁？ package main
import (
`fmt`
`time`
)
func product(num int) chan int {
ch := make(chan int, 1)
go func(num int) {
for i := 0; i < num; i++ {
ch <- i
}
}(num)
return ch
}
func main() {
in
浏览 14提问于2019-03-15得票数 0
1回答
有两种类似的情况，我想与您进行比较--唯一的区别是处理值生成的方法。
第一种情况:选择的情况之一中的值生成
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
generateValues := func(done <-chan interface{}) <-chan int {
values := make(chan int)
go func() {
defer fmt
浏览 3提问于2022-01-29得票数 1
下面是来自的代码片段
package main
import "fmt"
func sum(s []int, c chan int) {
sum := 0
for _, v := range s {
sum += v
}
c <- sum // send sum to c
}
func main() {
s := []int{7, 2, 8, -9, 4, 0}
c := make(chan int)
go sum(s[:len(s)/2], c)
go sum(s[len(s)/2:
浏览 8提问于2016-03-07得票数 0
我正在尝试实现一个函数，我可以用两个goroutine和不同的参数调用它。每一个都会操纵自己的字符串，它们会通过一个通道将它们的字符串发送给彼此，并比较结果。是我在这方面的尝试(Go Playground linked)：
func swap_values(str string, strChan1 chan string, strChan2 chan string, done chan bool) {
str += "test"
strChan1 <- str
<-strChan2
done <- true
}
这就是死锁。对于我对该函数的两次
浏览 7提问于2020-02-20得票数 3
回答已采纳
我觉得这一定是一种常见的Go模式，但似乎找不到解决方案。 假设有一个Go应用程序正在建立出站TCP连接。我将使用net.Dial，并在连接后生成一个Go例程来处理套接字(net.Conn)。这是非常简单和常见的。我想知道的是什么是最好的方法让这个Go例程有一个通道，它正在读写来自这个套接字的消息？select只能在通道上等待，而不能在net.Conn上等待。是否要轮询套接字以获取数据，然后检查通道以获取数据？这似乎是令人难以置信的低效。
浏览 17提问于2020-09-03得票数 0
回答已采纳
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
我想要运行多个峡谷，做一些处理，将结果放入通道，当至少有一个goroutine完成时，完成所有其他的，并从通道返回结果。
因此，我试着使用等待组来实现这个，但是我似乎还没有正确地使用等待组。
package optimizer
import (
"github.com/tevino/abool"
"errors"
"sync"
"runtime"
"log"
)
type Optimizer stru
浏览 1提问于2018-05-18得票数 1
回答已采纳
1回答
我在Go中开始学习并发性，在阅读了一些示例之后，我想尝试一个系统，在这个系统中，每秒钟都会在终端中打印当前的时间，用户可以在终端中输入任何文本，并且在终端中打印出相同的文本(或者我们可以做任何其他的事情，比如，如果只写了一篇将被打印出来的特定文本)。基本上，我想出这个表单来编写我的代码：
函数输出每个secondGetInput:函数检查用户输入的时间，如果输入不是空的，获取它的值并将其放入另一个函数将要从一个值读取的变量中，如果值不是空的，则将readShowInput：(如果“完成”)写在输入中，程序将结束，一切都将停止。
现在，我想出了这个解决方案，但是在输入了一个代码之后，我得到了错误
浏览 6提问于2022-07-07得票数 0
我想知道为什么我们需要运行wg.Wait() in goroutine
// This one works as expected...
func main() {
var wg sync.WaitGroup
for i:=0; i<5; i++ {
wg.Add(1)
go func() {
defer wg.Done()
}()
time.Sleep(time.Second)
}
go func() {
wg.Wait()
}()
}
但这一
浏览 2提问于2014-12-04得票数 7
回答已采纳
描述：
下面是Go编程语言第9-7章中的代码。
在调用任何其他函数之前，必须调用func New()来插入容器。
奇怪的是，作者在func New()中创建了一个阻塞通道来发送请求。
我认为这将使程序以一种连续的方式工作。
例如:如果同时有多个goroutine调用func ()，那么服务器 goroutine的循环中会以串行方式处理请求吗？
有人能给我解释一下吗？谢谢!
/**
* create a memo and run the monitor goroutine of it.
* here is a question:
* since the request channel is
浏览 1提问于2020-04-11得票数 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
回答已采纳
2回答
通过渠道进行通信
、、
考虑一下这种情况。有一家主要的goroutine和十家子公司。他们都可以访问channel。主通道向该信道发送1000号码，子通道将从中读取。是否有任何保证，每个附属戈鲁丁将准确读取100个数字，或者这个数额可能会变化，就像一些戈鲁丁将读取99个数字和另一个101个？
浏览 0提问于2017-11-23得票数 0
回答已采纳
对于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回答
我目前正在学习教程，并进入了有关频道的部分，在进行一些测试时，我发现了一种我很难理解的奇怪行为
下面的代码会产生死锁错误
package main
import "fmt"
func main() {
c := make(chan string)
c <- "test"
fmt.Printf("%v", <- c)
}
但是，执行以下操作之一可以修复代码
使用缓冲信道：
package main
import "fmt"
func main() {
c := make(chan
浏览 9提问于2021-05-26得票数 1
回答已采纳
我的解决方案如下所示，但是在下面的代码中是否存在竞争条件(它会出现恐慌)吗？ c := make(chan struct{})
for i := 0; i < 1000000; i++ {
go func() {
select {
case <-c:
default:
close(c)
}
}()
} 我想是的，但是go测试-race没有检测到它，从经验上讲，我不能让它恐慌。
浏览 26提问于2021-04-12得票数 0
回答已采纳
如何检查通道是否有可供读取的值？
我不想在读取频道时阻塞。我想看看它有没有价值。如果有的话，我会读的。如果它还没有，我会做一些其他的事情，稍后再检查。
浏览 3提问于2010-08-04得票数 42
回答已采纳
3回答
我想了解这里的日常工作是如何进行的。
问题1: GO例程继承了主要的GO例程/函数吗？
问题2:我还想知道如果我把“嗨，向上”发送到msg频道，为什么它没有收到行:13？
1 package main
2
3 import "fmt"
4
5 func main() {
6 msg := make(chan string, 2) //channel (bidirectional channel) of type string
7
8 msg <- "hi whats up"
9 fmt.Pr
浏览 1提问于2018-02-04得票数 1
回答已采纳
我正在学习使用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
回答已采纳
我有下面的程序作为概念的证明。我正在尝试聚合来自chann的结果，也就是说，将chann的每个实例合并到一个公共切片中。对于我的方法，这可能吗？
因此，对于下面的示例，我的输出将是一个包含以下内容(按任意顺序)的切片：[]int{0,1,2}，谢谢。
func DoStuff(i int, chann chan[]int, wg *sync.WaitGroup) {
defer wg.Done()
chann <-[]int{i}
}
func main() {
var wg sync.WaitGroup
chann := make(chan in
浏览 3提问于2020-06-02得票数 0
回答已采纳
我有以下代码：
package main
import "net"
import "fmt"
import "bufio"
func main() {
conn, _ := net.Dial("tcp", "irc.freenode.net:6667")
reader := bufio.NewReader(conn)
go func() {
str, err := reader.ReadString('\n')
if err != nil
浏览 2提问于2013-04-26得票数 74
回答已采纳
我不明白为什么不能工作，但是这个可以工作。
正如我所理解的，goroutine异步地发送值true到a和12到b。在主函数中，a被阻塞，直到它接收到一个值。为什么当我重新排列它使b在a之前被阻塞时，它会导致死锁？
浏览 0提问于2019-01-24得票数 2
回答已采纳
我有一个http服务器，还有一个通道，如果通道不是空的，我可以通过它来调用函数functionA()。在mainHandler()中有一些将值发送到通道的操作(未显示)。
我的目标：
每当有什么东西被发送到通道时，我希望functionA()被调用并与mainHandler()并发运行，但是看起来它们一次只运行一个。我必须等待functionA()完成，然后mainHandler()才能处理另一个请求。
如果对我做错了什么有任何帮助，我将不胜感激。
func main() {
c := make(chan string)
go func() {
for s :
浏览 1提问于2020-10-13得票数 0
1回答
下面是并发示例：
这是代码：
package main
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 0, 1
for {
select {
case c <- x:
x, y = y, x + y
case <- quit:
fmt.Println("quit")
return
}
}
}
func main() {
浏览 6提问于2016-10-11得票数 0
回答已采纳
我正在努力学习Go，我正在使用。
我写了以下代码，
var wg sync.WaitGroup
func foo(c chan int, someValue int) {
defer wg.Done()
c <- someValue * 5
}
func main() {
fooVal := make(chan int)
for i := 0; i < 10; i++ {
go foo(fooVal, i)
wg.Add(1)
}
wg.Wait() // Wait for all routine
浏览 0提问于2018-07-26得票数 2
回答已采纳
我有两组代码-读取包含随机文本行的文件，并将每行加载到一个通道。我不明白为什么会返回一个错误。案例1返回“致命错误:所有goroutines都处于休眠状态--死锁！”但是案例#是可行的。
案例#1
func main () {
file, err := os.Open("/Users/sample/Downloads/wordlist")
if err != nil {
log.Fatal(err)
}
lines := make (chan string)
scanner := bufio.NewScanner(file)
for scanner.Scan() {
浏览 2提问于2019-04-17得票数 0
我正在尝试编写一个代码，它可以对文件进行并发读取，并将内容发布到一个通道。
是到我的代码的链接，代码：
func main() {
bufferSize := int64(10)
f, err := os.Open("tags-c.csv")
if err != nil {
panic(err)
}
fileinfo, err := f.Stat()
if err != nil {
fmt.Println(err)
return
}
filesize := int64
浏览 0提问于2019-02-21得票数 0
回答已采纳
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
回答已采纳
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
回答已采纳
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
回答已采纳
为什么我的代码在从通道读取时死锁(然后崩溃)，我希望它在通道完全读取后在读取时阻塞，但不会崩溃。我知道这是一种死锁状态，因为没有人在通道上写入和读取数据块。
如何更改代码以读取所有频道内容，然后从main退出，而不是crash。
Go游乐场：
package main
import (
"fmt"
"sync"
)
func main() {
var wg sync.WaitGroup
news := make(chan int, 10)
wg.Add(1)
go foo(&wg, news)
浏览 36提问于2018-08-31得票数 3
回答已采纳
1回答
我正在试验并行子测试，我碰到了一个goroutine死锁错误。假设tt是一个具有有效值的表测试，而LastIndex是正在测试的函数，下面的代码运行所有测试，但是出错：
for _, tt := range tests {
tt := tt
t.Run("foo", func(t *testing.T) {
t.Parallel()
done := make(chan bool)
for {
select {
case <-done:
浏览 4提问于2020-11-02得票数 1
回答已采纳
1回答
我包装了一个队列来实现Writer和Reader接口(分别用于推送和弹出)。
我需要不断地监听队列，并处理通过的每条消息。当队列被表示为通道时，这很简单，但在其他情况下则更难：
loop:
for {
var data []byte
select {
case <-done:
break loop
case _, err := queue.Read(data):
fmt.Println(string(data))
}
浏览 0提问于2018-10-28得票数 0
有人能解释一下为什么第一段代码运行而第二段代码失败吗？
第一项：
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
回答已采纳
2回答
我刚刚开始学习使用golang的多线程编程，我正在尝试使用BFS遍历编写一个多线程web爬虫，但是我无法让代码工作。我得到的错误是fatal error: all goroutines are asleep - deadlock!
我将粘贴下面的代码，但让我从概念上解释它是如何工作的：
我有一个主线程(主函数本身)和N个工作线程。我有意选择在固定数量的工作线程中使用BFS方法，因为使用DFS方法，我将不得不为每个新URL生成一个新线程来爬行，这可能会成为上下文切换的一个巨大负担。
我使用两个频道：
urlsToCrawl:主线程将URL发送到工作线程。
urlsDiscovered:工
浏览 6提问于2022-01-08得票数 0
2回答
我正在学习有关goroutines和频道的知识，并且有一个问题，如果多个goroutines尝试从同一个通道获取数据，会发生什么。
go运行时如何确保正在被多个goroutines读取的通道中的数据只提供给等待通道的一个goroutines，而不复制或发送到多个goroutines。
当有多个goroutines试图从完全相同的通道获取数据时，go运行时是否阻止竞争条件？是否有某种排序，例如，先到先得的数据给等待等待的人？
浏览 4提问于2021-01-21得票数 0
1回答
从非缓冲通道读取
、、
我正在尝试理解非缓冲通道，所以我写了一个小应用程序，它迭代用户输入的数组，做一些工作，将信息放在非缓冲通道上，然后读取它。但是，我无法从通道中读取。这是我的代码 toProcess := os.Args[1:]
var wg sync.WaitGroup
results := make(chan string)
errs := make(chan error)
for _, t := range toProcess {
wg.Add(1)
go Worker(t, "text", results, errs, &wg)
}
go func()
浏览 45提问于2019-03-24得票数 1
回答已采纳
我有一个频道，接收器是主频道。我产生了多个goroutine，每个goroutine都通过通道发送一个字符串。 现在，这会导致死锁，因为我没有使用close函数正确地关闭通道。问题是，我不知道将创建多少goroutines，因此无法知道何时关闭通道。 我试过使用WaitGroup，问题是，我读到我不能在goroutine中使用Add，而我应该在主进程/ goroutine中使用wg.Add(1)，我尝试在父goroutine中使用Add来产生子goroutine，这也导致了死锁 package main import (
"fmt"
"sync"
浏览 15提问于2019-01-13得票数 2
回答已采纳
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
回答已采纳
这个例子摘自“围棋之旅”：
显然，程序输出应该有10行:5行表示"hello“，5行表示"world”。
但我们有：
Linux -9行
MacOS - 10行
Linux输出(9行)：
$ go run 1.go
hello
world
hello
world
hello
world
world
hello
hello
MacOS X输出(10行)：
$ go run 1.go
hello
world
world
hello
hello
world
hello
world
hello
world
谁能解释一下-为什么
Linux uname -a
Linu
浏览 3提问于2015-07-23得票数 1
回答已采纳
1回答
假设我有一堆正在运行的goroutines，它们执行HTTP请求，并将在随机时间返回。我启动了goroutines (其中包含waitgroups和一个cancel )，我希望它们继续执行请求，直到返回OK (可能超时)。当第一个goroutine返回时，它会调用cancel，所有其他goroutine都应该停止。 我不确定如何设置goroutine函数用例，如果上下文没有完成，它将执行代码？ 例如，我知道如何使用time.After()，但是如何让它立即执行代码，而不是在一段时间之后执行呢？ for {
select {
case <-ctx.Done
浏览 10提问于2019-10-04得票数 0
我有一个缓冲通道，我特意将其限制为2个元素。当我在没有读取的情况下向通道写入更多的元素时，我会像预期的那样得到一个死锁。但是，如果我使用goroutine来写我的通道，这个问题就解决了。为什么？
// Function to process messages in an array. We stop processing once we
// encounter the string 'stop' even if there are other messages
func processCmd(s []string, c chan int) {
msgCount :=
浏览 0提问于2020-07-08得票数 0
我的代码如下：
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
回答已采纳
我试着通过运行小程序来学习频道。我不理解下面的程序，因为它给出了一个奇怪的输出：
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
我正在使用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
回答已采纳
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
回答已采纳
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
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
回答已采纳
3回答
为什么会出现下面的死锁？
package main
import (
"fmt"
)
var quit chan bool
var buffer chan string
func main() {
buffer = make(chan string)
quit = make(chan bool)
go func() {
i:=0
for {
select {
case <- quit:
fmt.Println(
浏览 2提问于2016-06-03得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
