golang并发 04-并发模式

pipeline模式

//pipeline模式
func Pipeline() {
	fmt.Println("---开始工作---")
	coms := parts(10)
	part := process(coms)
	out(part)
	time.Sleep(100 * time.Second)
}

func parts(num int) <-chan int {
	ch := make(chan int, 5)
	go func() {
		defer close(ch)
		for i := 1; i <= num; i++ {
			ch <- i
			time.Sleep(1 * time.Second)
		}
	}()
	return ch
}

func process(ch <-chan int) chan string {
	ch2 := make(chan string, 5)
	go func() {
		defer close(ch2)
		for c := range ch { //没有数据会一直堵塞，直到关闭通道
			ch2 <- "组装" + strconv.Itoa(c)
		}
	}()
	return ch2
}

func out(ch <-chan string) {
	go func() {
		for k := range ch {
			fmt.Println("整合" + k + "，进行发送")
		}
	}()
}

• 流水线由一道道工序构成，每道工序通过channel把数据传递到下一个工序
• 每道工序一般会对应一个函数，函数里有协程和channel协程一般用于处理数据并把它放入channel中整个函数会返回这个channel以供下一道工序使用
• 最终要有一个组织者(示例中的main函数)把这些工序串起来

扇出扇入模式

func merge(ins ...<-chan string) <-chan string {
	out := make(chan string)
	var wg sync.WaitGroup
	wg.Add(len(ins))

	//把每个管道中的值给out
	p := func(in <-chan string) {
		defer wg.Done()
		for c := range in {
			out <- c
		}
	}

	//依次处理多个管道
	for _, sc := range ins {
		go p(sc)
	}

	//等所有管道处理完，就关闭out
	go func() {
		wg.Wait()
		close(out)
	}()
	
	return out
}

Futures模式

在实际需求中,有大量的任务之间相互独立、没有依赖所以为了提高性能,这些独立的任务就可以并发执行

//未来模式
func Funture() {
	veg := vegetables()
	wa := water()

	fmt.Println("已经安排洗菜和烧水了")
	time.Sleep(3 * time.Second)

	fmt.Println("看看水和菜可以了没")
	vegs := <-veg
	was := <-wa

	fmt.Println(vegs, was, "开始做火锅")
}

func water() <-chan string {
	wa := make(chan string)
	go func() {
		time.Sleep(3 * time.Second)
		wa <- "烧好水了"
	}()
	return wa
}

func vegetables() <-chan string {
	veg := make(chan string)
	go func() {
		time.Sleep(3 * time.Second)
		veg <- "洗好菜了"
	}()
	return veg
}

- - - 以后在实战中继续更新 - - -