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 結(jié)構(gòu)體，包含一個(gè) URL 字段
type Job struct {
	URL string
}

// worker 函數(shù)用于處理作業(yè)，接收請求者、作業(yè)通道、結(jié)果通道和等待組作為參數(shù)
func worker(requester *insrequester.Request, jobs <-chan Job, results chan<- *http.Response, wg *sync.WaitGroup) {
	for job := range jobs {
		// 使用請求者獲取 URL 對應(yīng)的響應(yīng)
		res, _ := requester.Get(insrequester.RequestEntity{Endpoint: job.URL})
		// 將結(jié)果發(fā)送到結(jié)果通道，并減少等待組計(jì)數(shù)
		results <- res
		wg.Done()
	}
}

func main() {
	// 創(chuàng)建并加載請求者
	requester := insrequester.NewRequester().Load()

	// 定義要處理的 URL 列表
	urls := []string{"http://example.com", "http://example.org", "http://example.net"}
	// 定義工作池中的工作者數(shù)量
	numWorkers := 2

	// 創(chuàng)建作業(yè)通道和結(jié)果通道
	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)
	}

	// 將作業(yè)發(fā)送到工作者池
	wg.Add(len(urls))
	for _, url := range urls {
		jobs <- Job{URL: url}
	}
	close(jobs)
	wg.Wait()

	// 收集結(jié)果并輸出
	for i := 0; i < len(urls); i++ {
		fmt.Println(<-results)
	}
}

// 創(chuàng)建請求者并加載配置
requester := insrequester.NewRequester().Load()

// 定義要處理的 URL 列表
urls := []string{"http://example.com", "http://example.org", "http://example.net"}
maxConcurrency := 2 // 限制并發(fā)請求的數(shù)量

// 創(chuàng)建一個(gè)用于限制并發(fā)請求的通道
limiter := make(chan struct{}, maxConcurrency)

// 遍歷 URL 列表
for _, url := range urls {
    limiter <- struct{}{} // 獲取一個(gè)令牌。在這里等待令牌從限制器釋放
    go func(url string) {
        defer func() { <-limiter }() // 釋放令牌
        // 使用請求者進(jìn)行 POST 請求
        requester.Post(insrequester.RequestEntity{Endpoint: url})
    }(url)
}

// 等待所有 goroutine 完成
for i := 0; i < cap(limiter); i++ {
    limiter <- struct{}{}
}

// 創(chuàng)建請求者并加載配置
requester := insrequester.NewRequester().Load()

// 定義要處理的 URL 列表
urls := []string{"http://example.com", "http://example.org", "http://example.net"}
maxConcurrency := int64(2) // 設(shè)置最大并發(fā)請求數(shù)量

// 創(chuàng)建一個(gè)帶權(quán)重的信號量
sem := semaphore.NewWeighted(maxConcurrency)
ctx := context.Background()

// 遍歷 URL 列表
for _, url := range urls {
    // 在啟動 goroutine 前獲取信號量權(quán)重
    if err := sem.Acquire(ctx, 1); err != nil {
       fmt.Printf("無法獲取信號量：%v\n", err)
       continue
    }

    go func(url string) {
       defer sem.Release(1) // 在完成時(shí)釋放信號量權(quán)重
       // 使用請求者獲取 URL 對應(yīng)的響應(yīng)
       res, _ := requester.Get(insrequester.RequestEntity{Endpoint: url})
       fmt.Printf("%s: %d\n", url, res.StatusCode)
    }(url)
}

// 等待所有 goroutine 釋放它們的信號量權(quán)重
if err := sem.Acquire(ctx, maxConcurrency); err != nil {
    fmt.Printf("等待時(shí)無法獲取信號量：%v\n", err)
}

func worker(errChan chan<- error) {
    // 執(zhí)行任務(wù)
    if err := doTask(); err != nil {
        errChan <- err // 將任何錯(cuò)誤發(fā)送到錯(cuò)誤通道
    }
}

func main() {
    errChan := make(chan error, 1) // 用于存儲錯(cuò)誤的緩沖通道

    go worker(errChan)

    if err := <-errChan; err != nil {
        // 處理錯(cuò)誤
        log.Printf("發(fā)生錯(cuò)誤：%v", err)
    }
}

func worker(errChan chan<- error, job Job) {
 // 執(zhí)行任務(wù)
 if err := doTask(job); err != nil {
  errChan <- err // 將任何錯(cuò)誤發(fā)送到錯(cuò)誤通道
 }
}

func listenErrors(done chan struct{}, errChan <-chan error) {
 for {
  select {
  case err := <-errChan:
   // 處理錯(cuò)誤
  case <-done:
   return
  }
 }
}

func main() {
 errChan := make(chan error, 1000) // 存儲錯(cuò)誤的通道
 done := make(chan struct{})       // 用于通知 goroutine 停止的通道

 go listenErrors(done, errChan)
 
 for _, job := range jobs {
   go worker(errChan, job)
 }

 // 等待所有 goroutine 完成（具體方式需要根據(jù)代碼的實(shí)際情況進(jìn)行實(shí)現(xiàn)）
 done <- struct{}{} // 通知 goroutine 停止監(jiān)聽錯(cuò)誤
}

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 {
        // 為每個(gè) URL 啟動一個(gè) goroutine
        g.Go(func() error {
            // 替換為實(shí)際的 HTTP 請求邏輯
            _, err := fetchURL(ctx, url)
            return err
        })
    }

    // 等待所有請求完成
    if err := g.Wait(); err != nil {
        log.Printf("發(fā)生錯(cuò)誤：%v", err)
    }
}

func work() error {
  // 進(jìn)行一些工作
  return err
}

func main() {
 go func() {
   err := work()
   if err != nil {
     // 處理錯(cuò)誤
   }
 }()

 // 等待工作完成的某種方式
}