Golang中如何限制goroutine的数量

如果你只想运行五个goroutine，就不能启动k个goroutine。只需启动五个，并使用通道在它们之间传递URL和结果。

尝试类似这样的代码：

package main

import (
	"fmt"
	"strings"
	"sync"
)

func main() {
	input := `http://www.example.com/1
http://www.example.com/2
http://www.example.com/3
http://www.example.com/4
http://www.example.com/5
http://www.example.com/6
http://www.example.com/7
http://www.example.com/8
http://www.example.com/9
http://www.example.com/10`
	urls := strings.Split(input, "\n")

	// 用于传递URL的通道
	work := make(chan string)

	// 用于传递结果的通道
	results := make(chan string)

	// 启动三个工作goroutine
	var done sync.WaitGroup
	for i := 0; i < 3; i++ {
		done.Add(1)
		go func() {
			defer done.Done()
			for w := range work {
				// TODO: 对任务w执行实际工作
				results <- fmt.Sprintf("my result for '%s': '%s", w, strings.ToUpper(w))
			}
		}()
	}

	// 等待WaitGroup，然后关闭结果通道
	go func() {
		done.Wait()
		// 所有工作goroutine已完成，不会再有结果
		close(results)
	}()

	// 将所有URL作为任务传递到工作通道
	go func() {
		for _, url := range urls {
			work <- url
		}
		// 所有URL已传递，可以关闭工作通道
		close(work)
	}()

	// 等待结果
	var combinedResult string
	for result := range results {
		combinedResult += result + "\n"
	}

	// 完成
	fmt.Println(combinedResult)
}

另请参阅 https://goplay.space/#o9nqqSCswq1

在Go语言中，可以使用带缓冲的channel和sync.WaitGroup来限制goroutine的数量并确保每个URL只被处理一次。以下是实现方案：

package main

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

func main() {
	inputString := flag.String("input", "http://golang.org\nhttp://golang.org", "url's")
	flag.Parse()
	k := strings.Split(*inputString, "\n")
	
	// 创建带缓冲的channel来限制goroutine数量
	maxGoroutines := 5
	guard := make(chan struct{}, maxGoroutines)
	
	// 创建URL channel
	urls := make(chan string, len(k))
	
	// 创建WaitGroup等待所有goroutine完成
	var wg sync.WaitGroup
	
	// 将所有URL发送到channel
	for _, url := range k {
		urls <- url
	}
	close(urls)
	
	// 启动固定数量的goroutine处理URL
	for url := range urls {
		wg.Add(1)
		guard <- struct{}{} // 获取信号量
		
		go func(u string) {
			defer wg.Done()
			defer func() { <-guard }() // 释放信号量
			
			// 使用GET方法处理URL
			resp, err := http.Get(u)
			if err != nil {
				fmt.Printf("Error fetching %s: %v\n", u, err)
				return
			}
			defer resp.Body.Close()
			
			fmt.Printf("Successfully processed %s with status: %d\n", u, resp.StatusCode)
		}(url)
	}
	
	wg.Wait()
}

另一种更简洁的方法是使用worker pool模式：

package main

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

func worker(id int, urls <-chan string, wg *sync.WaitGroup) {
	defer wg.Done()
	
	for url := range urls {
		// 使用GET方法处理URL
		resp, err := http.Get(url)
		if err != nil {
			fmt.Printf("Worker %d: Error fetching %s: %v\n", id, url, err)
			continue
		}
		defer resp.Body.Close()
		
		fmt.Printf("Worker %d: Successfully processed %s with status: %d\n", id, url, resp.StatusCode)
	}
}

func main() {
	inputString := flag.String("input", "http://golang.org\nhttp://golang.org", "url's")
	flag.Parse()
	k := strings.Split(*inputString, "\n")
	
	// 创建URL channel
	urls := make(chan string, len(k))
	
	// 创建WaitGroup
	var wg sync.WaitGroup
	
	// 启动5个worker goroutine
	numWorkers := 5
	for i := 1; i <= numWorkers; i++ {
		wg.Add(1)
		go worker(i, urls, &wg)
	}
	
	// 发送所有URL到channel
	for _, url := range k {
		urls <- url
	}
	close(urls)
	
	wg.Wait()
}

两种方法都能确保：

1. 最多同时运行5个goroutine
2. 每个URL只被处理一次
3. 所有URL都会被处理

第一种方法使用信号量模式，第二种使用worker pool模式。两种都是Go中常见的并发控制模式。