我目前正在点击一个 api 来收集数据以供我自己处理等等。目前，我每秒执行 100 个 http.Get，我想知道每秒执行大约 1000 个并发 http.Get 的最佳方法是什么。

这是我现在拥有的:

waitTime := time.Second
var lastID uint64 = 1234567890
for {
    for i := 0; i < 100; i++ {
        var tmpID uint64 = lastID
        lastID++
        go func(ID uint64) {
            err = scrape(ID) // this does the http.Get and saves the
                             // resulting json into postgresql
            if err != nil {
                errStr := strings.TrimSpace(err.Error())
                if strings.HasSuffix(errStr, "Too Many request to server") {
                    log.Println("hit a real 429")
                    panic(err)
                }
            }
        }(tmpID)
    }
    time.Sleep(waitTime - time.Now().Sub(now)) // this is here to             
                                  // ensure I dont go over the limit
}

我正在访问的 API 速率限制为 1000 个请求/秒。

我使用 go func(ID) 的原因是这样我就可以逐步增加我的 ID，而不必担心使用锁来访问“下一个 ID 是什么”。 我只是觉得我做错了。总的来说，我也很陌生。

我还假设我必须将我的 ubuntu 服务器上的 ulimit 提高到超过 1000 以处理所有这些打开的连接。

非常感谢任何提示或建议!

最佳答案

您的 http 客户端是否缓存连接？默认的。

By default, Transport caches connections for future re-use. This may leave many open connections when accessing many hosts. This behavior can be managed using Transport's CloseIdleConnections method and the MaxIdleConnsPerHost and DisableKeepAlives fields.

为什么在循环中生成 goroutine 而不是在内部生成一些带有循环的 goroutine，如果达到限制它可能会退缩一点。

原始示例(我没有测试它。可能包含错别字)。

numWorkers := 1000
var delay time.Duration = 0.01 //10 ms (iirc) =)
var maxDelay time.Duration = 0.1 //100 ms (i guess)
quit := make(chan struct{})

for i := 0; i < numWorkers ; i++ {
    go func(ID, shift uint){
       var iter := 0
       var curDelay time.Duration = delay

       for {              
          select {
          case <-quit:
              return

          default:              
              //0th worker: lastID + 0 + 0, lastID + 100 + 0, lastID + 200 + 0, ...
              //1st worker: lastID + 0 + 1, lastID + 100 + 1, lastID + 200 + 2, ...
              //...
              //99th worker: lastID + 0 + 99, lastID + 100 + 99, lastID + 100 + 299, ...
              curID := ID + iter * numWorkers + shift
              err = scrape(curID) // this does the http.Get and saves the
                                // resulting json into postgresql
              if err != nil {
                  errStr := strings.TrimSpace(err.Error())
                  if strings.HasSuffix(errStr, "Too Many request to server") {                              log.Println("hit a real 429")
                      if curDelay > maxDelay {
                         return //or panic, whatever you want
                      }
                      time.Sleep(curDelay)
                      curdelay = curdelay * 2 //exponential delay: 10ms, 20ms, 40ms, 80ms, return/panic
                      continue //no increment on iter
                  }
              }    
              //increment on success
              iter++
              time.Sleep(1) // 1000 workers, each make request and sleep for 1 sec, sounds like 1000 rpm
          }
       }
    }(lastID, i)
}

ID 从不重叠，但可能会有漏洞。但是你不能在没有同步的情况下避免它(互斥量很好)，而且，你可能可以在 1000rpm 上做到这一点，但是性能会受到更多工作人员的影响。

close(quit) 当你想停止的时候。

关于http - 每秒执行 ~1000 个 http.Get 的最佳方法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37598532/