Golang并发设计中的死锁问题探讨

Golang并发设计中的死锁问题探讨 我是Go语言的新手。前几天决定开始学习它，主要是因为其通过通道实现的一流并发特性。

我构建了一个玩具应用程序，作为学习如何使用通道的一种方式。 这个应用程序：

1. 从源位置下载文件。
2. 对它们应用一些转换。
3. 将转换后的文件上传到输出位置。

转换步骤是最慢的。 我理想的设计是让下载器一次收集少量文件，刚好足以持续供应并让转换器池保持忙碌。当一个转换器处理完一个文件后，它会将其交给完成器进行上传。

以下是我对这个设计的尝试，使用 time.Sleep 来模拟长时间的处理过程。

package main

import (
	"fmt"
	"strconv"
	"time"
)

type task struct {
	name string
	path string
	startTime time.Time
}

func downloader(id int, toDownload chan task, toProcess chan task) {
	for {
		task := <- toDownload
		fmt.Printf("[downloader_%v]: downloading %v \n", id, task.name)
		time.Sleep(5 * time.Second)
		toProcess <- task
	}
}

func transformer(id int, toProcess chan task, toFinish chan task) {
	for {
		task := <- toProcess
		fmt.Printf("[processor_%v]: processing %v \n", id, task.name)
		time.Sleep(20 * time.Second)
		toFinish <- task
	}
}

func finisher(id int, toFinish chan task, finished chan task) {
	for {
		task := <- toFinish
		fmt.Printf("[finisher_%v]: uploading %v \n", id, task.name)
		time.Sleep(7 * time.Second)
		finished <- task
	}
}

func fetchJobs(n int) *[]task {
	tasks := make([]task, n)
	for i := 0; i < n; i++ {
		name := "job_" + strconv.Itoa(i);
		tasks[i] = task{name: name}
	}
	return &tasks
}

func main() {
	start := time.Now()

	n := 10

	toDownload := make(chan task)
	toProcess := make(chan task)
	toFinish := make(chan task)
	finished := make(chan task)


	for i := 0; i < 4; i++ {
		go downloader(i, toDownload, toProcess)
	}

	for i := 0; i < 10; i++ {
		go transformer(i, toProcess, toFinish)
	}

	for i := 0; i < 4; i++ {
		go finisher(i, toFinish, finished)
	}

	jobs := fetchJobs(n)
	for _, j := range *jobs {
		toDownload <- j
	}

	for task := range finished {
		fmt.Printf("finished %v in %s \n", task.name, time.Since(task.startTime) / time.Second)
	}

	fmt.Printf("all tasks finished in %s", time.Since(start) / time.Second)
}

以下是部分输出。

[processor_1]: processing job_0
[processor_3]: processing job_6
[processor_7]: processing job_5
[processor_6]: processing job_4
[downloader_2]: downloading job_9
[processor_5]: processing job_7
[downloader_1]: downloading job_8
[processor_8]: processing job_8
[processor_9]: processing job_9
[finisher_1]: uploading job_0
[finisher_3]: uploading job_1
[finisher_2]: uploading job_3
[finisher_0]: uploading job_2
[finisher_0]: uploading job_4
finished job_2 in 9.223372036s
finished job_1 in 9.223372036s
finished job_3 in 9.223372036s
finished job_0 in 9.223372036s
[finisher_3]: uploading job_5
[finisher_1]: uploading job_7
[finisher_2]: uploading job_6
[finisher_2]: uploading job_9
finished job_6 in 9.223372036s
finished job_7 in 9.223372036s
finished job_5 in 9.223372036s
finished job_4 in 9.223372036s
[finisher_1]: uploading job_8
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
	/Users/.../go/src/drive_uploader/main.go:79 +0x4b9

goroutine 6 [chan receive]:
main.downloader(0x0, 0xc000066060, 0xc0000660c0)
	/Users/.../go/src/drive_uploader/main.go:17 +0x74
created by main.main
	/Users/.../go/src/drive_uploader/main.go:63 +0x135

goroutine 7 [chan receive]:
main.downloader(0x1, 0xc000066060, 0xc0000660c0)
	/Users/.../go/src/drive_uploader/main.go:17 +0x74
created by main.main
	/Users/.../go/src/drive_uploader/main.go:63 +0x135
...
...

不幸的是，我遇到了死锁，并且不清楚是什么原因导致的。 我尝试调整每个goroutine的数量；有些组合能够成功运行而不会死锁。但这并不理想。

我也尝试过使用带缓冲的通道以及WaitGroup。同样……有些组合会成功运行，有些则不会。

任何帮助或反馈都将不胜感激！我特别想知道在Go中是否有更符合语言习惯的方法。