我有两个 go 例程:
func f1 {
... some code
// critical section 1 (CS1)
... critical section code
// end criticla section 1
... more code
}
func f2 {
... some code
// critical section 2 (CS2)
... critical section code
// end criticla section 2
... more code
}
func main() {
go f1()
go f2()
}
Run Code Online (Sandbox Code Playgroud)
确保这些例程中的关键部分始终交替执行的正确方法是什么?
换句话说,CS1 只能在 CS2 之后执行,反之亦然:CS1、CS2、CS1、CS2、CS1 等。
我正在构建一个 Go 应用程序,它使用 goroutines 的“工作池”,最初我启动池创建许多工作人员。我想知道多核处理器中的最佳工人数量是多少,例如在具有 4 核的 CPU 中?我目前正在使用以下方法:
// init pool
numCPUs := runtime.NumCPU()
runtime.GOMAXPROCS(numCPUs + 1) // numCPUs hot threads + one for async tasks.
maxWorkers := numCPUs * 4
jobQueue := make(chan job.Job)
module := Module{
Dispatcher: job.NewWorkerPool(maxWorkers),
JobQueue: jobQueue,
Router: router,
}
// A buffered channel that we can send work requests on.
module.Dispatcher.Run(jobQueue)
Run Code Online (Sandbox Code Playgroud)
完整的实现在下
job.NewWorkerPool(maxWorkers) 和 module.Dispatcher.Run(jobQueue)
我使用工作池的用例:我有一个服务,它接受请求并调用多个外部 API,并将它们的结果聚合到一个响应中。每个调用都可以独立于其他调用,因为结果的顺序无关紧要。我将调用分派到工作池,其中每个调用都以异步方式在一个可用的 goroutine 中完成。一旦工作线程完成,我的“请求”线程就会在获取和聚合结果的同时继续监听返回通道。完成所有操作后,最终聚合结果将作为响应返回。由于每个外部 API 调用可能呈现可变响应时间,因此某些调用可以比其他调用更早完成。
比如说,我有一个函数,func foo(x) error { if x == y ... return err}我想在多个 go 例程中执行并聚合错误(最好使用错误组,如下面的常见示例),但不确定这是否可能?
import "golang.org/x/sync/errgroup"
var g errgroup.Group
g.Go(func() error {
resp, err := http.Get(url)
if err == nil {
resp.Body.Close()
}
return err
})
Run Code Online (Sandbox Code Playgroud) 我正在调试一个通过 Goland 用 go 编写的程序。在调试器中,我可以在正在运行的不同 goroutine 之间进行选择。我发现在我的 goroutine 旁边还有很多其他名为 runtime.gopark 的 goroutine,我怀疑这些是在线程池中等待工作的其他线程。但是,我在网上找不到任何答案。是这样吗?如果不是,它实际上在做什么?
PS这是事件的照片:
我有两个通道,首先给我一些字符串,我需要将其过滤为相同的值,然后将结果发送到第二个通道
func main() {
c := make(chan string, 5)
o := make(chan string, 5)
arr := []string{"aa", "ab", "ab", "bb", "bb", "ba", "cc"}
for _, v := range arr {
c <- v
go removeDuplicates(c, o)
time.Sleep(1 * time.Second)
fmt.Println("output: ", <-o)
}
}
func removeDuplicates(cIn, cOut chan string) {
last := ""
for cur, isOpen := <-cIn; isOpen; {
if cur != last {
fmt.Printf("val: %s, last: %s\n", cur, last)
last = cur
cOut <- cur
//close(cOut)
}
} …Run Code Online (Sandbox Code Playgroud) 我一直在试图找到一些东西来回答这个问题,但我找不到任何谈论它的东西。
假设我在 Go 中有一个函数,如下所示:
func main() {
// assume this wrapped in a waitgroup or something
// so that it doesnt exit
go queue.ConsumeAndDoSomething()
go api.StartServer()
}
Run Code Online (Sandbox Code Playgroud)
我这里有两个 goroutine,它们做完全不同的事情,理想情况下,如果另一个 goroutine 崩溃/恐慌,一个应该继续运行。如果队列操作失败,API 服务器应该会受到影响,反之亦然。
我不确定这是否可能(甚至推荐)。有没有一种干净的方法可以做到这一点,或者一旦 Goroutine 发生恐慌,整个程序应该退出吗?
情况1
package main
func main() {
dogChan := make(chan int)
dogChan <- 1
}
Run Code Online (Sandbox Code Playgroud)
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/Users/xuzhongwei/Source/awesomeProject/main.go:5 +0x50
Run Code Online (Sandbox Code Playgroud)
案例2
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/Users/xuzhongwei/Source/awesomeProject/main.go:5 +0x50
Run Code Online (Sandbox Code Playgroud)
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/Users/xuzhongwei/Source/awesomeProject/main.go:9 +0x72
Run Code Online (Sandbox Code Playgroud)
案例3
package main
func main() {
dogChan := make(chan int)
go func(ch chan int) {
}(dogChan)
dogChan <- 1
} …Run Code Online (Sandbox Code Playgroud) 如果导入的库产生一个可能会出现恐慌的 goroutine 怎么办?在这种情况下,开发人员无法阻止程序退出。
就像这段代码一样,调用一个带有延迟恢复的坏库并没有帮助,因为该库正在生成一个发生恐慌的 goroutine,并且它无法被 main 的恢复捕获。
我是否理解正确的是,唯一的补救措施是在为项目选择依赖项时非常小心,并希望作者不要做类似的事情?
package main
import (
"fmt"
"time"
)
func main() {
defer func() {
r := recover()
if r != nil {
fmt.Println("panic caught")
}
}()
badLibrary()
}
func badLibrary() {
go recklessFunction()
time.Sleep(time.Second)
}
func recklessFunction() {
panic("something went wrong")
}
Run Code Online (Sandbox Code Playgroud) 考虑一组检查工作,每个检查工作都有独立的逻辑,因此它们似乎很适合并发运行,例如:
type Work struct {
// ...
}
// This Check could be quite time-consuming
func (w *Work) Check() bool {
// return succeed or not
//...
}
func CheckAll(works []*Work) {
num := len(works)
results := make(chan bool, num)
for _, w := range works {
go func(w *Work) {
results <- w.Check()
}(w)
}
for i := 0; i < num; i++ {
if r := <-results; !r {
ReportFailed()
break;
}
}
}
func ReportFailed() {
// …Run Code Online (Sandbox Code Playgroud) 我想同时对切片的元素执行操作
我正在使用sync/errgroup包来处理并发
这是 Go Playground 上的最小复制品https://go.dev/play/p/yBCiy8UW_80
import (
"fmt"
"golang.org/x/sync/errgroup"
)
func main() {
eg := errgroup.Group{}
input := []int{0, 1, 2}
output1 := []int{}
output2 := make([]int, len(input))
for i, n := range input {
eg.Go(func() (err error) {
output1 = append(output1, n+1)
output2[i] = n + 1
return nil
})
}
eg.Wait()
fmt.Printf("with append %+v", output1)
fmt.Println()
fmt.Printf("with make %+v", output2)
}
Run Code Online (Sandbox Code Playgroud)
输出
with append [3 3 3]
with make [0 0 3]
Run Code Online (Sandbox Code Playgroud)
与预期相比[1 …
go ×10
goroutine ×10
concurrency ×5
channel ×2
goland ×1
optimization ×1
slice ×1
worker-pool ×1