go-zero 2—并发处理数据包 mr(mapReduce) 的原理讲解

自己实现的代码地址

https://github.com/wanmei002/goutil/blob/master/mr/mapreduce.go

如果觉的自己golang 功底不强的话，可以先看我的实现代码：汉字注释，省略了一些go-zero的相互依赖，没有像go-zero兼容那么多的需求，相对简单

原理

这里用到了一个概念mapReduce, 那什么是 mapReduce 呢？这里简单的说下我的理解：

mapReduce 是一种分布式处理数据并合并数据的概念，如果你想并发处理大量数据，你需要把很多数据分成很多份，让不同的机器或线程执行这些数据，并合并处理的结果；而mapReduce 的理念就是你把数据给它, 它自己切分数据分给不同的机器执行，并自动合并结果(自己的理解，如果是片面的不正确的请留言，再此不胜感激)。

当然了在这里实现的比较简单，简单介绍下这里的实现逻辑:

1. 要处理的数据放到一个无缓冲的管道里，再来一个协程从这个无缓冲的管道里读取要处理的数据，然后把读取出来的数据开一个协程用 传入的方法处理;
2. 创建一个无缓冲的管道, 用来保存执行的结果, 让合并结果的协程从这个管道里读取数据, 然后合并数据, 写入合并数据的管道里
3. 创建一个用来停止其它协程的管道, 如果执行中有什么错误就关闭这个管道里，同时停止执行其它协程，返回失败
4. 最后要把没有关闭的管道关闭了

需要传入的参数

这里需要传入三个参数(方法) :

1. 发送要处理的数据
2. 每条数据要怎么处理，并把处理结果写入到指定的channel里，如果遇到执行错误是否停止执行
3. 把处理数据的结果按需求合并到一起

逻辑图如下

贴上 go-zero mr包的主要实现代码

下面贴的代码是 go-zero mr包的代码；这里说的比较简单，实际实现上还是比较复杂的；有时间的话可以看看源码；

传递要处理的数据

创建一个无缓冲的channel，执行用户传递数据的逻辑

func buildSource(generate GenerateFunc) chan interface{} {
	source := make(chan interface{})
	threading.GoSafe(func() {
		defer close(source)
		generate(source)// generate 是用户传入的方法
	})
	return source
}

创建中断channel和数据传递channel

output 是传递合并结果的channel，collector 用于传递 并发处理数据得到的结果，done 用于执行异样的时候通知其它goroutine退出执行

output := make(chan interface{})
collector := make(chan interface{}, options.workers)
done := syncx.NewDoneChan()

并发执行处理数据的逻辑

for {
		select {
		case <-done:// 如果异常 这里通知停止执行
			return
		case pool <- lang.Placeholder:
			// 从channel中取出要处理的数据
			item, ok := <-input
			if !ok {
				<-pool
				return
			}

			wg.Add(1)
			// 开启协程 并发的执行处理数据的逻辑
			threading.GoSafe(func() {
				defer func() {
					wg.Done()
					<-pool
				}()
				// 这个里面实际是调用用户传入的处理逻辑
				mapper(item, writer)
			})
		}
	}

调用示例

这里用的是我自己实现的方法来运行的，实际上跟 go-zero 调用的方式是一样的

	//要处理的数据
    uid := []int{1,2,3,4,5,6}
    //传递数据的逻辑
    a := func(source chan<- interface{}){
        for _,v := range uid {
            source <- v
        }
    }
    
    // 处理数据的逻辑
    b := func(item interface{}, writer mr.Writer, cancel func(err error)){
        tmp := item.(int) + 1
        writer.Writer(tmp)
    }
    
    // 合并的数据逻辑
    c := func(pipe <-chan interface{}, writer mr.Writer, cancel func(err error)){
        var uid []int
        for v := range pipe {
            uid = append(uid, v.(int))
        }
        fmt.Println(uid)
        writer.Writer(uid)
    }
    
    // 开始并发处理数据
    res, err := mr.MapReduce(a, b, c)

并发的执行多个方法

实际上 Finish 方法底层调用的也是 mapReduce 这个方法

    a1 := func() error {
        log.Println("aaaa")
        return nil
    }
    
    b1 := func() error {
        log.Println("bbbb")
        return errors.New("err about bbbb")
    }
    
    c1 := func() error {
        log.Println("cccc")
        return nil
    }
    
    err := mr.Finish(a1, b1, c1)