相关疑难解决方法(0)

我在下面找到了代码,net/http/httptest并想知道selectGo中的空语句是什么.

go s.Config.Serve(s.Listener)
if *serve != "" {
  fmt.Fprintln(os.Stderr, "httptest: serving on", s.URL)
  select {}
}

我是一位golang新手，正在尝试了解此问题的正确设计模式。我当前的解决方案似乎很冗长，我不确定哪种更好的方法。

我正在尝试设计一个系统，该系统：

1. 执行N个例程
2. 尽快返回每个goroutine的结果
3. 如果goroutine返回特定值，则应该杀死其他goroutine将取消。

目标：我想开始一些goroutine，但是如果一个例程返回特定结果，我想取消这些例程。

我试图了解我的代码是否超级“臭”，或者这是否是规定的处理方式。我仍然感觉不太好，因此我们将不胜感激。

这是我写的：

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {

    ctx := context.Background()
    ctx, cancel := context.WithCancel(ctx)

    fooCheck := make(chan bool)
    barCheck := make(chan bool)

    go foo(ctx, 3000, fooCheck)
    go bar(ctx, 5000, barCheck)

    for fooCheck != nil ||
        barCheck != nil {
        select {
        case res, ok := <-fooCheck:
            if !ok {
                fooCheck = nil
                continue
            }
            if res == false {
                cancel()
            }
            fmt.Printf("result of foocheck: %t\n", …

此示例取自tour.golang.org/#63

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world")
    say("hello")
}

输出

hello
world
hello
world
hello
world
hello
world
hello

为什么world只打印4时代而不是5？

编辑:答案可以引用golang规范:

程序执行从初始化主包然后调用main函数开始.当函数main返回时,程序退出.它不等待其他(非主要)goroutines完成.

我一直在努力解决我在Golang并发中遇到的这个简单问题.我一直在寻找所有可能的解决方案,但没有发现我的问题(或者我可能会错过一个).这是我的代码:

package main

import (
    "fmt"
    "time"
)

func producer(ch chan int, d time.Duration, num int) {

    for i:=0; i<num; i++ {
        ch <- i
        time.Sleep(d)
    }
}

func main() {
    ch := make(chan int)

    go producer(ch, 100*time.Millisecond, 2)
    go producer(ch, 200*time.Millisecond, 5)

    for {
        fmt.Println(<-ch)    
    }

    close(ch)
}

它打印错误:

致命错误:所有goroutines都睡着了 - 僵局!

goroutine 1 [chan receive]:main.main()D:/Code/go/src/testconcurrency/main.go:23 + 0xca退出状态2

什么是避免此错误的有效方法？,谢谢.

我有这段 Go 代码。我需要有这种能力：在一个地方写入通道，并在另一个地方读出它们（反之亦然）：

package main
import "fmt"
var ch1=make(chan int)
var ch2=make(chan int)

func f1() {
    select {
    case <- ch1:fmt.Println("ch1")
    default: fmt.Println("default")
    }
}
func f2() {
    select {
    case <- ch2:fmt.Println("ch2")
    default: fmt.Println("default")
    }
}
func main() {
    go f1()
    go f2()
    ch1<-1
    ch2<-2
}

它总是打印这样的东西：

default
ch1
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
    /tmp/sandbox970110849/prog.go:22 +0xa0

此外，我试过这个：

package main
import (
    "fmt"
    "sync"
)
var ch1=make(chan int)
var ch2=make(chan int)

func …

var wg sync.WaitGroup
var v int32 = 0 
for i = 0; i < 100; i++{
   go func(){
       wg.Add(1) // wrong place
       atomic.AddInt32(&v,1)
       wg.Done()
   } 
}
wg.Wait()
fmt.Println(v)

这是我从这个视频中看到的一段代码https://subscription.packtpub.com/video/application_development/9781788994880/97598/97608/goroutines

但v总是小于100，我认为原因可能是wg.Wait()因为我们放入wg.Add(1)匿名函数并且在同一个 goroutinewg.Done()中将被立即调用，因此 main goroutine 从阻塞状态恢复执行。

但是如果我们将wg.Add(1)放入 for 循环中， v 将始终为100。

var wg sync.WaitGroup
var v int32 = 0 
for i = 0; i < 100; i++{
   wg.Add(1)
   go func(){
       atomic.AddInt32(&v,1)
       wg.Done()
   } 
}
wg.Wait()
fmt.Println(v)

我的问题是为什么我们可以保证 …