GoLang 并发性——从不调用主例程

Question

我是golang新手。尝试学习并发。使用通道分叉后连接点的概念现在困扰着我。这是我的代码

package main

import (
    "fmt"
    "net/http"

    "github.com/vijay-psg587/golang/golang-srv/src/modules/test-dir-DONT-USE/concurrency/status-checker/models"
)

func printChannelData(str string, url chan models.URLCheckerModel) {
    
    fmt.Println("Data in channel is: ", str)
    resp, err := http.Get(str)
    if err != nil {

        url <- models.URLCheckerModel{
            StatusCode: 500,
            URL:        str,
            Message:    err.Error(),
        }

    } else {
        

        url <- models.URLCheckerModel{
            StatusCode: 200,
            URL:        str,
            Message:    resp.Status,
        }
    }

}

func main() {
    fmt.Println("Main started...")
    

    links := []string{"http://google.com", "http://golang.org", "http://amazon.com"}

    op := make(chan models.URLCheckerModel)
    defer close(op)
    for i := 0; i < len(links); i++ {
        // call to goroutine

        go func(str string) {
            printChannelData(str, op)
        }(links[i])

        

    }

    for data := range op {

        fmt.Println("data receveied:", data)
    }

    fmt.Println("Main ended...")
}

现在当我执行这个时，我的 go 函数并没有结束。它获取数据

Main started...
Data in channel is:  http://amazon.com
Data in channel is:  http://google.com
Data in channel is:  http://golang.org

data receveied: {200 http://google.com 200 OK}

data receveied: {200 http://golang.org 200 OK}

data receveied: {200 http://amazon.com 200 OK}

三围棋开始运行，但它永远不会结束。根本不回到主要的 go 例程

现在，如果我像这样进行更改，（在连接点）

// for data := range op {

    //  fmt.Println("data receveied:", data)
    // }
    fmt.Println("data received:", <-op)
    fmt.Println("data received:", <-op)
    fmt.Println("data received:", <-op)

而不是 for 循环，然后我获取数据并且主要的 go 例程也结束了。不确定我在哪里犯了错误以及为什么从不调用主例程

Main started...
Data in channel is:  http://amazon.com
Data in channel is:  http://golang.org
Data in channel is:  http://google.com
data received: {200 http://google.com 200 OK}
data received: {200 http://golang.org 200 OK}
data received: {200 http://amazon.com 200 OK}
Main ended...

Answer 1

在 Go 中对通道使用 for range 时，迭代器将继续阻塞，直到底层通道关闭。

x := make(chan int, 2)
x <- 1
x <- 2
close(x) // Without this, the following loop will never stop

for i := range x {
  print(i)
}

在你的例子中，使用 defer 意味着通道只会在父方法退出后关闭（即在循环完成后），这会导致死锁。

通常，当使用 fan-out/fan-in 模型时，您会使用类似 sync.WaitGroup 的东西来协调关闭 channel/continuing。

在您的情况下，这可能类似于以下内容：

links := []string{"http://google.com", "http://golang.org", "http://amazon.com"}

op := make(chan models.URLCheckerModel)
var wg sync.WaitGroup

for i := 0; i < len(links); i++ {
    wg.Add(1)
    go func(str string) {
        defer wg.Done()
        printChannelData(str, op)
    }(links[i])
}

go func() {
  wg.Wait()
  close(op)
}()

for data := range op {
    fmt.Println("data receveied:", data)
}

Answer 2

您的频道是无缓冲的，因此，您在 main.go 中的代码将无限地运行，等待某事发生，因为代码无法继续，因为无缓冲的频道是同步的，任何人在那个通道上监听只能在收到一个值时停止监听（在这种情况下，因为有时请求到达或永远不会到达需要时间，代码将无限地运行 inside main.go） .

您有两个选择：

或者您将频道的缓冲区定义为列表的大小 URL 并使您的代码真正异步和并发。
```
    op := make(chan models.URLCheckerModel, len(links))
```

或者您必须创建多个频道，每个频道一个 URL，所以当每一个都被处理时，值被加载并且你关闭您在搜索方法中的频道。

 links := []string{"http://google.com", "http://golang.org", "http://amazon.com"}

 for i := 0; i < len(links); i++ {
    // call to goroutine
    op := make(chan models.URLCheckerModel)

    go func(str string) {
       printChannelData(str, op)

       fmt.Println(<-op)
    }(links[i])
}



func printChannelData(str string, url chan models.URLCheckerModel) {
   fmt.Println("Data in channel is: ", str)
   resp, err := http.Get(str)
   if err != nil {
       url <- models.URLCheckerModel{
           StatusCode: 500,
           URL:        str,
           Message:    err.Error(),
      }
  } else {
      url <- models.URLCheckerModel{
          StatusCode: 200,
          URL:        str,
          Message:    resp.Status,
     }
 }

    close(url)
 }

GoLang 并发性——从不调用主例程

GoLang concurrency- Main routine is never called

go

concurrency

goroutine

channels