在Golang中,可以使用goroutine和channel来实现线程池。下面是一个简单的示例:
package main
import (
"fmt"
"sync"
)
type Job struct {
id int
}
type Worker struct {
id int
jobChannel chan Job
quit chan bool
}
func NewWorker(id int, jobChannel chan Job) *Worker {
return &Worker{
id: id,
jobChannel: jobChannel,
quit: make(chan bool),
}
}
func (w *Worker) Start(wg *sync.WaitGroup) {
go func() {
defer wg.Done()
for {
select {
case job := <-w.jobChannel:
fmt.Printf("Worker %d started job %d\n", w.id, job.id)
// 模拟处理任务
// time.Sleep(time.Second)
fmt.Printf("Worker %d finished job %d\n", w.id, job.id)
case <-w.quit:
return
}
}
}()
}
func (w *Worker) Stop() {
go func() {
w.quit <- true
}()
}
type Pool struct {
jobChannel chan Job
workers []*Worker
wg sync.WaitGroup
}
func NewPool(numWorkers, maxJobs int) *Pool {
jobChannel := make(chan Job, maxJobs)
workers := make([]*Worker, numWorkers)
for i := 0; i < numWorkers; i++ {
workers[i] = NewWorker(i+1, jobChannel)
}
return &Pool{
jobChannel: jobChannel,
workers: workers,
}
}
func (p *Pool) Start() {
for _, worker := range p.workers {
worker.Start(&p.wg)
p.wg.Add(1)
}
}
func (p *Pool) AddJob(job Job) {
p.jobChannel <- job
}
func (p *Pool) Stop() {
for _, worker := range p.workers {
worker.Stop()
}
p.wg.Wait()
close(p.jobChannel)
}
func main() {
pool := NewPool(3, 10)
pool.Start()
for i := 0; i < 10; i++ {
pool.AddJob(Job{id: i + 1})
}
pool.Stop()
}
在上面的示例中,我们定义了一个Job结构体表示需要执行的任务,Worker结构体表示线程池中的工作协程。Pool结构体表示线程池,其中包含一个任务通道和多个工作协程。
在Pool的Start方法中,我们为每个Worker启动一个独立的协程,并等待工作协程完成任务。
在Pool的AddJob方法中,我们将任务放入任务通道,Worker会从通道中获取任务并执行。
最后,在main函数中,我们创建一个线程池,并向线程池中添加10个任务。然后,调用线程池的Stop方法等待任务执行完成。
请注意,上述示例中的任务仅仅是打印一些信息,你可以根据实际需求来修改任务的执行逻辑。