golang并发执行的几种方式小结

    wg := sync.WaitGroup{}
    var result1 interface{}
    var result2 interface{}
    wg.Add(2)
    go func() {
        defer func() {
            wg.Done()
        }()
        result1 = funcA()
    }()
    go func() {
        defer func() {
            wg.Done()
        }()
        result1 = funcB()
    }()  
    wg.wait() 

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "strings"
    "sync"
)
func main() {
    idList := []string{"x", "xx"}
    wg := sync.WaitGroup{}
    dataMap := sync.Map{} //  sync.Map是线程安全的，如果使用 map去存储返回结果会报错，
                          //  接受返回结果也可以是channel，channel也是线程安全的
    for _, id := range idList {
        wg.Add(1)
        go func(id string) {
            defer func() {
                wg.Done()
            }()
            data := PostData(id)
            dataMap.Store(id, data)
        }(id)
    }
    wg.Wait()
    for _, id := range idList {
        fmt.Println(dataMap.Load(id))
    }
}
func PostData(id string) string {
    url := "http:xx"
    method := "POST"
    payload := strings.NewReader(fmt.Sprintf(`{"id":"%s"}`, id))
    client := &http.Client{}
    req, err := http.NewRequest(method, url, payload)
    if err != nil {
        fmt.Println(err)
        return ""
    }
    req.Header.Add("Content-Type", "application/json")
    res, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return ""
    }
    defer res.Body.Close()
    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
        fmt.Println(err)
        return ""
    }
    return string(body)
}

package main
import (
    "fmt"
    "net/http"
    "sync"
)
func main() {
    urls := []string{"http://a.com", "http://b.com", "http://c.com"}
    // 控制并发度为2
    concurrency := 2
    sem := make(chan struct{}, concurrency)
    var wg sync.WaitGroup
    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            sem <- struct{}{} // 获取信号量
            defer func() {
                <-sem // 释放信号量
                wg.Done()
            }()
            resp, err := http.Get(url)
            if err != nil {
                fmt.Printf("Error fetching %s: %v\n", url, err)
                return
            }
            defer resp.Body.Close()
            fmt.Printf("Fetched %s with status code %d\n", url, resp.StatusCode)
        }(url)
    }
    wg.Wait()
    fmt.Println("All URLs fetched")
}

package main
import (
    "fmt"
    "net/http"
)
func main() {
    urls := []string{"http://www.google.com", "http://www.facebook.com", "http://www.apple.com"}
    // 创建一个通道来控制并发度为2
    concurrency := make(chan struct{}, 2)
    // 创建一个通道来接收响应结果
    results := make(chan string, len(urls))
    for _, url := range urls {
        // 启动一个goroutine来请求url
        go func(url string) {
            // 从通道中获取一个信号，表示可以开始请求
            concurrency <- struct{}{}
            // 发送http GET请求
            resp, err := http.Get(url)
            if err != nil {
                results <- fmt.Sprintf("%s -> error: %s", url, err)
            } else {
                results <- fmt.Sprintf("%s -> status: %s", url, resp.Status)
                resp.Body.Close()
            }
            // 释放一个信号，表示请求已完成
            <-concurrency
        }(url)
    }
    // 从结果通道中读取所有响应结果
    for i := 0; i < len(urls); i++ {
        fmt.Println(<-results)
    }
}

func getData(ctx context.Context, result chan string, id string) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("running get Data")
            return
        default:
            resultData := PostData(id)
            result <- resultData
        }
    }
}
func main() {
    idList := []string{"xx", "xxx"}
    ctx := context.Background()
    var result = make(chan string, 2)
    go getData(ctx, result, idList[0])
    go getData(ctx, result, idList[1])
    fmt.Println(<-result)
    fmt.Println(<-result)
}
func PostData(id string) string {
    url := "http://xxx"
    method := "POST"
    payload := strings.NewReader(fmt.Sprintf(`{"id":"%s"}`, id))
    client := &http.Client{}
    req, err := http.NewRequest(method, url, payload)
    if err != nil {
        fmt.Println(err)
        return ""
    }
    req.Header.Add("Content-Type", "application/json")
    res, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return ""
    }
    defer res.Body.Close()
    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
        fmt.Println(err)
        return ""
    }
    return string(body)
}