Master-Worker模式golang实现

Master-Worker模式

Master-Worker模式是常用的并行计算模式。它的核心思想是系统由两类进程协作工作：Master进行和Worker进行。Master负责接收和分配任务，Worker负责处理子任务。当各个Worker子进程处理完成后，会将结果返回给Master，由Master做归纳和总结。其好处是能将一个大任务分解成若干个子任务，并行执行，从而提高系统的吞吐量。

master-worker模式流程图

下面是一个master-worker模式的例子：

worker.go

package main

import "fmt"

// Job 需要处理的任务，简单定义一下
type Job struct {
	num int
}
func NewJob(num int) Job {
	return Job{num: num}
}
type Worker struct {
	id        int                //workerID
	WorkerPool chan chan Job      //worker池
	JobChannel chan Job            //worker从JobChannel中获取Job进行处理
	Result    map[interface{}]int //worker将处理结果放入reuslt
	quit      chan bool          //停止worker信号
}
func NewWorker(workerPool chan chan Job, result map[interface{}]int, id int) Worker {
	return Worker{
		id:        id,
		WorkerPool: workerPool,
		JobChannel: make(chan Job),
		Result:    result,
		quit:      make(chan bool),
	}
}
func (w Worker) Start() {
	go func() {
		for {
			//将worker的JobChannel放入master的workerPool中
			w.WorkerPool <- w.JobChannel
			select {
			//从JobChannel中获取Job进行处理，JobChannel是同步通道，会阻塞于此
			case job := <-w.JobChannel:
				//处理这个job
				//并将处理得到的结果存入master中的结果集
				x := job.num * job.num
				fmt.Println(w.id, ":", x)
				w.Result[x] = w.id
			//停止信号
			case <-w.quit:
				return
			}
		}
	}()
}
func (w Worker) Stop() {
	go func() {
		w.quit <- true
	}()
}

master.go

package main

type Master struct {
	WorkerPool chan chan Job //worker池
	Result    map[interface{}]int  //存放worker处理后的结果集
	jobQueue  chan Job      //待处理的任务chan
	workerList []Worker      //存放worker列表，用于停止worker
}
var maxWorker int

// NewMaster maxWorkers:开启线程数
//result :结果集
func NewMaster(maxWorkers int, result map[interface{}]int) *Master {
	pool := make(chan chan Job, maxWorkers)
	maxWorker = maxWorkers
	return &Master{WorkerPool: pool, Result: result, jobQueue: make(chan Job, 2*maxWorkers)}
}
func (m *Master) Run() {
	//启动所有的Worker
	for i := 0; i < maxWorker; i++ {
		work := NewWorker(m.WorkerPool, m.Result, i)
		m.workerList = append(m.workerList, work)
		work.Start()
	}
	go m.dispatch()
}
// 分配任务
func (m *Master) dispatch() {
	for {
		select {
		// 从作业队列中获取一个待处理的作业，因为是无缓冲通道，所以会阻塞
		case job := <-m.jobQueue:
			go func(job Job) {
				//从workerPool中取出一个worker的JobChannel
				jobChannel := <-m.WorkerPool
				//向这个JobChannel中发送job，worker中的接收配对操作会被唤醒
				jobChannel <- job
			}(job)
		}
	}
}

// AddJob 添加任务到任务通道
func (m *Master) AddJob(num int) {
	job := NewJob(num)
	//向任务通道发送任务
	m.jobQueue <- job
}

// Stop 停止所有任务
func (m *Master) Stop() {
	for _, v := range m.workerList {
		v.Stop()
	}
}

test.go

package main
import (
	"fmt"
	"time"
)
func main() {
	result := map[interface{}]int{}
	mas := NewMaster(4, result)
	mas.Run()
	for i := 0; i < 10; i++ {
		mas.AddJob(i)
	}
	time.Sleep(time.Millisecond)
	//mas.Stop()
	fmt.Println("result=", result)
}

运行结果每次都是不同的，这里只展示某一次的运行结果：

1 : 81
2 : 4
2 : 9
2 : 16
2 : 64
2 : 36
2 : 49
3 : 1
0 : 0
1 : 25
result= map[0:0 1:3 4:2 9:2 16:2 25:1 36:2 49:2 64:2 81:1]

其它并发模式

参考资料：

https://www.cnblogs.com/moonyaoo/p/12846605.html