Golang代码示例：手写一个简单的Golang协程池

爱被打了一巴掌 2024-02-19 11:12 40阅读 0赞

下面是一个简单的手写协程池的示例代码：

package main
    
    import (
    	"fmt"
    	"sync"
    )
    
    type Job struct {
        
    	ID  int
    	Num int
    }
    
    type Result struct {
        
    	JobID  int
    	Square int
    }
    
    func worker(id int, jobs <-chan Job, results chan<- Result) {
        
    	for job := range jobs {
        
    		result := Result{
        
    			JobID:  job.ID,
    			Square: job.Num * job.Num,
    		}
    		results <- result
    	}
    }
    
    func main() {
        
    	// 定义并发数和任务数
    	numWorkers := 5
    	numJobs := 10
    
    	jobs := make(chan Job, numJobs)
    	results := make(chan Result, numJobs)
    
    	// 创建协程池
    	var wg sync.WaitGroup
    	for i := 1; i <= numWorkers; i++ {
        
    		wg.Add(1)
    		go func(id int) {
        
    			defer wg.Done()
    			worker(id, jobs, results)
    		}(i)
    	}
    
    	// 提交任务到协程池
    	for i := 1; i <= numJobs; i++ {
        
    		job := Job{
        
    			ID:  i,
    			Num: i,
    		}
    		jobs <- job
    	}
    	close(jobs)
    
    	// 收集任务结果
    	go func() {
        
    		wg.Wait()
    		close(results)
    	}()
    
    	// 处理任务结果
    	for result := range results {
        
    		fmt.Printf("Job ID: %d, Square: %d\n", result.JobID, result.Square)
    	}
    }

在上述代码中，我们首先定义了`Job`和`Result`结构体，分别用于表示任务和任务结果。然后，在`worker`函数中，每个工作协程从`jobs`通道中接收任务，执行相应的计算，并将结果发送到`results`通道中。

在`main`函数中，我们创建了`jobs`和`results`通道，用于传递任务和接收结果。然后，使用`sync.WaitGroup`来跟踪工作协程的完成情况。

接下来，我们根据指定的并发数创建了工作协程，并将它们绑定到`worker`函数。然后，我们使用一个循环将任务提交到`jobs`通道中。

在提交完所有任务之后，我们关闭了`jobs`通道，以通知工作协程没有更多的任务可用。

接着，我们启动一个匿名协程来等待所有工作协程完成，并在完成后关闭`results`通道。

最后，我们从`results`通道中接收任务结果，并进行打印。

这样，我们就实现了一个简单的协程池，可以并发执行任务并收集结果。请注意，这只是一个基本示例，实际的协程池可能需要更复杂的逻辑和错误处理。