Golang并发发送HTTP请求的各种方法

go sendRequest("http://example.com")

urls := []string{"http://example.com", "http://another.com", ...}  
for _, url := range urls {  
go sendRequest(url)  
}

requester := insrequester.NewRequester().Load()  
  
urls := []string{"http://example.com", "http://example.org", "http://example.net"}  
for _, url := range urls {  
go requester.Get(insrequester.RequestEntity{Endpoint: url})  
}  
  
time.Sleep(2 * time.Second) // 等待 goroutine 完成

requester := insrequester.NewRequester().Load()  
wg := sync.WaitGroup{}  
  
urls := []string{"http://example.com", "http://example.org", "http://example.net"}  
wg.Add(len(urls))  
  
for _, url := range urls {  
go requester.Get(insrequester.RequestEntity{Endpoint: url})  
}  
  
wg.Wait() //等待所有要完成的 goroutine

requester := insrequester.NewRequester().Load()  
  
urls := []string{"http://example.com", "http://example.org", "http://example.net"}  
ch := make(chan string, len(urls))  
  
for _, url := range urls {  
go func() {  
res, _ := requester.Get(insrequester.RequestEntity{Endpoint: url})  
ch <- fmt.Sprintf("%s: %d", url, res.StatusCode)  
}()  
}  
  
for range urls {  
response := <-ch  
fmt.Println(response)  
}

// 定义 Job 结构体，包含一个 URL 字段
type Job struct {
	URL string
}
 
// worker 函数用于处理作业，接收请求者、作业通道、结果通道和等待组作为参数
func worker(requester *insrequester.Request, jobs <-chan Job, results chan<- *http.Response, wg *sync.WaitGroup) {
	for job := range jobs {
		// 使用请求者获取 URL 对应的响应
		res, _ := requester.Get(insrequester.RequestEntity{Endpoint: job.URL})
		// 将结果发送到结果通道，并减少等待组计数
		results <- res
		wg.Done()
	}
}
 
func main() {
	// 创建并加载请求者
	requester := insrequester.NewRequester().Load()
 
	// 定义要处理的 URL 列表
	urls := []string{"http://example.com", "http://example.org", "http://example.net"}
	// 定义工作池中的工作者数量
	numWorkers := 2
 
	// 创建作业通道和结果通道
	jobs := make(chan Job, len(urls))
	results := make(chan *http.Response, len(urls))
	var wg sync.WaitGroup
 
	// 启动工作者
	for w := 0; w < numWorkers; w++ {
		go worker(requester, jobs, results, &wg)
	}
 
	// 将作业发送到工作者池
	wg.Add(len(urls))
	for _, url := range urls {
		jobs <- Job{URL: url}
	}
	close(jobs)
	wg.Wait()
 
	// 收集结果并输出
	for i := 0; i < len(urls); i++ {
		fmt.Println(<-results)
	}
}
 

// 创建请求者并加载配置
requester := insrequester.NewRequester().Load()
 
// 定义要处理的 URL 列表
urls := []string{"http://example.com", "http://example.org", "http://example.net"}
maxConcurrency := 2 // 限制并发请求的数量
 
// 创建一个用于限制并发请求的通道
limiter := make(chan struct{}, maxConcurrency)
 
// 遍历 URL 列表
for _, url := range urls {
    limiter <- struct{}{} // 获取一个令牌。在这里等待令牌从限制器释放
    go func(url string) {
        defer func() { <-limiter }() // 释放令牌
        // 使用请求者进行 POST 请求
        requester.Post(insrequester.RequestEntity{Endpoint: url})
    }(url)
}
 
// 等待所有 goroutine 完成
for i := 0; i < cap(limiter); i++ {
    limiter <- struct{}{}
}

// 创建请求者并加载配置
requester := insrequester.NewRequester().Load()
 
// 定义要处理的 URL 列表
urls := []string{"http://example.com", "http://example.org", "http://example.net"}
maxConcurrency := int64(2) // 设置最大并发请求数量
 
// 创建一个带权重的信号量
sem := semaphore.NewWeighted(maxConcurrency)
ctx := context.Background()
 
// 遍历 URL 列表
for _, url := range urls {
    // 在启动 goroutine 前获取信号量权重
    if err := sem.Acquire(ctx, 1); err != nil {
       fmt.Printf("无法获取信号量：%v\n", err)
       continue
    }
 
    go func(url string) {
       defer sem.Release(1) // 在完成时释放信号量权重
       // 使用请求者获取 URL 对应的响应
       res, _ := requester.Get(insrequester.RequestEntity{Endpoint: url})
       fmt.Printf("%s: %d\n", url, res.StatusCode)
    }(url)
}
 
// 等待所有 goroutine 释放它们的信号量权重
if err := sem.Acquire(ctx, maxConcurrency); err != nil {
    fmt.Printf("等待时无法获取信号量：%v\n", err)
}

func worker(errChan chan<- error) {
    // 执行任务
    if err := doTask(); err != nil {
        errChan <- err // 将任何错误发送到错误通道
    }
}
 
func main() {
    errChan := make(chan error, 1) // 用于存储错误的缓冲通道
 
    go worker(errChan)
 
    if err := <-errChan; err != nil {
        // 处理错误
        log.Printf("发生错误：%v", err)
    }
}

func worker(errChan chan<- error, job Job) {
 // 执行任务
 if err := doTask(job); err != nil {
  errChan <- err // 将任何错误发送到错误通道
 }
}
 
func listenErrors(done chan struct{}, errChan <-chan error) {
 for {
  select {
  case err := <-errChan:
   // 处理错误
  case <-done:
   return
  }
 }
}
 
func main() {
 errChan := make(chan error, 1000) // 存储错误的通道
 done := make(chan struct{})       // 用于通知 goroutine 停止的通道
 
 go listenErrors(done, errChan)
 
 for _, job := range jobs {
   go worker(errChan, job)
 }
 
 // 等待所有 goroutine 完成（具体方式需要根据代码的实际情况进行实现）
 done <- struct{}{} // 通知 goroutine 停止监听错误
}

import "golang.org/x/sync/errgroup"
 
func main() {
    g, ctx := errgroup.WithContext(context.Background())
 
    urls := []string{"http://example.com", "http://example.org"}
    for _, url := range urls {
        // 为每个 URL 启动一个 goroutine
        g.Go(func() error {
            // 替换为实际的 HTTP 请求逻辑
            _, err := fetchURL(ctx, url)
            return err
        })
    }
 
    // 等待所有请求完成
    if err := g.Wait(); err != nil {
        log.Printf("发生错误：%v", err)
    }
}

func work() error {
  // 进行一些工作
  return err
}
 
func main() {
 go func() {
   err := work()
   if err != nil {
     // 处理错误
   }
 }()
 
 // 等待工作完成的某种方式
}