package main

import (
	"fmt"
	"net/http"
)

func main() {
	urls := []string{"http://example.com", "http://example.org"}

	for _, url := range urls {
		go func(url string) {
			resp, err := http.Get(url)
			if err != nil {
				fmt.Println("Error:", err)
				return
			}

			defer resp.Body.Close()

			// 處理響應內容或其他邏輯
		}(url)
	}

	// 等待所有請求完成
	// ...
}

package main

import (
	"fmt"
	"net/http"
	"sync"
)

func main() {
	urls := []string{"http://example.com", "http://example.org"}

	var wg sync.WaitGroup

	for _, url := range urls {
		wg.Add(1)
		go func(url string) {
			defer wg.Done()

			resp, err := http.Get(url)
			if err != nil {
				fmt.Println("Error:", err)
				return
			}

			defer resp.Body.Close()

			// 處理響應內容或其他邏輯
		}(url)
	}

	wg.Wait() // 等待所有請求完成
	// ...
}

package main

import (
	"fmt"
	"net/http"
)

func main() {
	urls := []string{"http://example.com", "http://example.org"}
	concurrency := 5
	sem := make(chan bool, concurrency)

	for _, url := range urls {
		sem <- true // 發(fā)送信號控制并發(fā)數量
		go func(url string) {
			defer func() { <-sem }() // 釋放信號

			resp, err := http.Get(url)
			if err != nil {
				fmt.Println("Error:", err)
				return
			}

			defer resp.Body.Close()

			// 處理響應內容或其他邏輯
		}(url)
	}

	// 等待所有請求完成
	// ...
}

package main

import (
	"fmt"
	"net/http"
	"sync"
)

type Worker struct {
	ID        int
	Request   chan string
	Responses chan string
}

func NewWorker(id int) *Worker {
	return &Worker{
		ID:        id,
		Request:   make(chan string),
		Responses: make(chan string),
	}
}

func (w *Worker) Start(wg *sync.WaitGroup) {
	go func() {
		defer wg.Done()

		for url := range w.Request {
			resp, err := http.Get(url)
			if err != nil {
				w.Responses <- fmt.Sprintf("Error: %s", err)
				continue
			}

			defer resp.Body.Close()

			// 處理響應內容或其他邏輯
			w.Responses <- fmt.Sprintf("Worker %d: %s", w.ID, "Response")
		}
	}()
}

func main() {
	urls := []string{"http://example.com", "http://example.org"}
	concurrency := 5

	var wg sync.WaitGroup
	wg.Add(concurrency)

	workers := make([]*Worker, concurrency)
	for i := 0; i < concurrency; i++ {
		workers[i] = NewWorker(i)
		workers[i].Start(&wg)
	}

	go func() {
		for _, url := range urls {
			for _, worker := range workers {
				worker.Request <- url
			}
		}

		for _, worker := range workers {
			close(worker.Request)
		}
	}()

	for _, worker := range workers {
		for response := range worker.Responses {
			fmt.Println(response)
		}
	}

	wg.Wait()
}

package main

import (
	"context"
	"fmt"
	"golang.org/x/sync/semaphore"
	"net/http"
)

func main() {
	// 創(chuàng)建請求者并加載配置
	requester := http.DefaultClient

	// 定義要處理的 URL 列表
	urls := []string{"http://example.com", "http://example.org", "http://example.net"}

	maxConcurrency := int64(2) // 設置最大并發(fā)請求數量

	// 創(chuàng)建一個帶權重的信號量
	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, err := requester.Get(url)
			if err != nil {
				fmt.Printf("請求失?。?v\n", err)
				return
			}
			defer res.Body.Close()

			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) {
    // 執(zhí)行任務
    if err := doTask(); err != nil {
        errChan <- err // 將任何錯誤發(fā)送到錯誤通道
    }
}
func main() {
    errChan := make(chan error, 1) // 用于存儲錯誤的緩沖通道
    go worker(errChan)
    if err := <-errChan; err != nil {
        // 處理錯誤
        log.Printf("發(fā)生錯誤：%v", err)
    }
}

func worker(errChan chan<- error, job Job) {
 // 執(zhí)行任務
 if err := doTask(job); err != nil {
  errChan <- err // 將任何錯誤發(fā)送到錯誤通道
 }
}
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 完成（具體方式需要根據代碼的實際情況進行實現(xiàn)）
 done <- struct{}{} // 通知 goroutine 停止監(jiān)聽錯誤
}

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("發(fā)生錯誤：%v", err)
    }
}