用goroutine和channel實現master-worker模式

這是一個建立於 的文章，其中的資訊可能已經有所發展或是發生改變。

什麼是master-worker模式？

如果你做過java服務端，那你對master-worker模式一定並不陌生，它是一種並行模式。

master-worker模式的主要作用是將master任務分別調度到多個worker上進行計算，計算之後將結果返回到master中進行合并整理。目的是減少一個進程對master中的任務處理的壓力。

master-worker模式流程圖：

圖源於網路

master-worker詳細流程圖：

圖源於網路

golang實現master-worker模式

worker

package worker

import (

    "fmt"

)

//封裝需要處理的資料結構

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

package master

import (

    "MasterWorkerPattern/worker"

)

type Master struct {

    WorkerPool chan chan worker.Job //worker池

    Result    map[interface{}]int  //存放worker處理後的結果集

    jobQueue  chan worker.Job      //待處理的任務chan

    workerList []worker.Worker      //存放worker列表，用於停止worker

}

var maxworker int

//maxWorkers:開啟線程數

//result :結果集

func NewMaster(maxWorkers int, result map[interface{}]int) *Master {

    pool := make(chan chan worker.Job, maxWorkers)

    maxworker = maxWorkers

    return &Master{WorkerPool: pool, Result: result, jobQueue: make(chan worker.Job,                                                  2*maxWorkers)}

}

func (m *Master) Run() {

    //啟動所有的Worker

    for i := 0; i < maxworker; i++ {

        work := worker.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 worker.Job) {

                //從workerPool中取出一個worker的JobChannel

                jobChannel := <-m.WorkerPool

                //向這個JobChannel中發送job，worker中的接收配對操作會被喚醒

                jobChannel <- job

            }(job)

        }

    }

}

//新增工作到任務通道

func (m *Master) AddJob(num int) {

    job := worker.NewJob(num)

    //向任務通道發送任務

    m.jobQueue <- job

}

//停止所有任務

func (m *Master) Stop() {

    for _, v := range m.workerList {

    v.Stop()

    }

}

test

// MasterWorkerPattern project main.go

package main

import (

    "MasterWorkerPattern/master"

    "fmt"

    "time"

)

func main() {

    result := map[interface{}]int{}

    mas := master.NewMaster(4, result)

    mas.Run()

    for i := 0; i < 10; i++ {

        mas.AddJob(i)

    }

    time.Sleep(time.Millisecond)

    //mas.Stop()

    fmt.Println("result=", result)

}

運行結果

0 : 81

3 : 0

0 : 4

0 : 36

0 : 25

0 : 49

0 : 64

1 : 1

3 : 9

2 : 16

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

這個運行結果是不確定的，在worker.go中有一行這樣的代碼：

x:=job.num*job.num

fmt.Println(w.id,":",x)，列印的是workerID和Job中num的平方，從最後的測試結果中可以看出id=0的這個worker計算了很多個Job，而其他的都很少，這並沒什麼影響，執行多次完全可能是不同的結果。另外，開啟多少個worker來為master工作比較好？如果你是2核，建議2-4個；如果你是4核，建議4-8，即i-2*i個，盡量用壓榨CPU。