当填充通道的函数调用未嵌入Goroutine中时，会出现死锁的原因是因为通道的发送和接收操作是阻塞的。如果在主Goroutine中调用填充通道的函数，并且该函数内部没有将填充操作放入新的Goroutine中运行，那么主Goroutine会一直等待通道有足够的空间来接收数据，而填充操作又无法进行，从而导致死锁的产生。因此，为了避免死锁，我们需要在填充通道的操作中使用Goroutine来进行并发执行，以确保填充操作和接收操作可以同时进行。
问题内容
我知道 sync 包及其 waitgroup 选项，我不想将其用于此测试。我正在测试一种信号量。
所以我有：
package main
import (
"fmt"
"os"
"time"
)
func main() {
fmt.print("wassap")
jobs := make(chan int)
processstarted := make(chan struct{}, 1)
processcompleted := make(chan struct{}, 1)
createjobs(jobs)
go func() {
worker(jobs, processstarted, processcompleted)
}()
go func() {
sync(processstarted, processcompleted)
}()
time.sleep(3600 * time.second)
fmt.print("\nend of main...")
interrupt := make(chan os.signal)
<-interrupt
}
func createjobs(jobs chan<- int) {
defer close(jobs)
for i := 1; i < 20; i++ {
jobs <- i
}
}
func worker(jobs <-chan int, processstarted <-chan struct{}, processcompleted <-chan struct{}) {
for {
select {
case i := <-jobs:
fmt.printf("\nfetching job #%d from channel", i)
time.sleep(2 * time.second)
case <-processstarted:
fmt.print("\nprocess started. waiting for it to be completed")
<-processcompleted
fmt.print("\nprocess completed")
}
}
}
func sync(processstarted chan<- struct{}, processcompleted chan<- struct{}) {
// acquire semaphore. send signal to channel to indicate that it is busy
processstarted <- struct{}{}
for i := 1; i < 5; i++ {
fmt.printf("\nprocessing %d", i)
time.sleep(5 * time.second)
}
// release semaphore
processcompleted <- struct{}{}
}
我想要测试的非常简单：我有一个 createjobs 函数，其唯一目的是将元素添加到通道，在本例中是一个 int 通道。然后我有一个 worker 将从该通道中提取对象并在提取下一个元素之前休眠 2 秒。
现在，还有同步功能。该函数的唯一目的是模拟 worker 运行时启动的进程。如果此进程处于活动状态，则在 sync 结束时应停止处理 jobs 元素，这就是为什么我有两个通道，一个表示进程已启动，另一个表示进程结束。
运行我的代码时出现以下错误：
fatal error: all goroutines are asleep - deadlock!
如果我修改 createjobs 的调用方式，将其包装在如下所示的 goroutine 中：
go func() {
createJobs(jobs)
}()
然后我的代码运行正确。
我只是想了解为什么会发生这种情况。我的意思是： main 例程正在执行，然后它调用 createjobs （无换行），因此 main 例程应该被阻止，直到此调用结束。一旦 createjobs 结束，就说明通道中有元素了。 main 继续执行并启动其他 goroutine worker 和 sync 来完成它们的工作。在 main 结束之前，我只是添加一个睡眠程序，以便为之前创建的 goroutine 提供完成时间。
我不是在询问这个问题的其他解决方案，我只是想知道当 createjobs 发生在 goroutine 之外时会发生什么。
解决方法
您将 jobs 声明为无缓冲通道，然后尝试将 20 个值同步推入其中。当您调用 createjobs(jobs) 时，这将阻止您的主函数。
将第 13 行更改为：
jobs := make(chan int, 20)
...将解决僵局。
编辑 - 评论中要求的澄清：
无缓冲通道没有容量，并且会阻止生产者的执行，直到消费者收到消息为止。
无缓冲通道的一个很好的类比是管道，在本例中，过程如下所示：
+------------------+ +------------+ +-------------+ | PRODUCER | | PIPE | | CONSUMER | | +---->| +----->| | | createJobs(jobs) | | unbuffered | | worker(...) | | | | channel | | | +------------------+ +------------+ +-------------+
发生死锁是因为 createjobs(jobs) 被同步调用，并且还没有消费者在运行。
当在 goroutine 中调用函数（producer）时它可以工作，因为基本上插入通道和读取通道是并行发生的？
是的。如果生产者被异步调用，它不会阻塞 main() 函数，因此消费者也将有机会被调用。在这种情况下，生产者将一一推送其所有任务，就像工作人员一一消费它们一样。
