Golang - channel练习 - 生产者消费者模型

---

无限数据 – 不需要关闭 chan

package main

import (
	"fmt"
	"math/rand"
)

// 放入 chan y 的结构体
type ret struct {
	i   int
	ret int
}

// 生产者, 产生随机数
func producer(c chan<- *int) {
	for {
		// num := rand.Int() // int 类型的随机数
		num := rand.Intn(100) // 100以内的 int 类型的随机数
		// num := rand.Int31() // int32 个随机数, 类型为 int32, 使用的话需要更改 ret 结构体中 i 的类型
		c <- &num
	}
}

// 开启多少个生产者
func goStartProducer(n int, c chan<- *int) {
	for i := 0; i < n; i++ {
		go producer(c)
	}
}

// 计算位数和
func calc(i int) int {
	sum := 0

	for i > 0 {
		sum = sum + i%10
		i = i / 10
	}

	return sum
}

// 消费者, 将 chan x 的数字取出, 放入 chan y 中
func consumer(c1 <-chan *int, c2 chan<- *ret) {
	for v := range c1 {
		vv := *v
		r := calc(vv)
		c2 <- &ret{
			i:   vv,
			ret: r,
		}
	}
}

// 开启多少个消费者
func goStartConsumer(n int, c1 <-chan *int, c2 chan<- *ret) {
	for i := 0; i < n; i++ {
		go consumer(c1, c2)
	}
}

// 输出位数和的结果
func getRet(c <-chan *ret) {
	for v := range c {
		fmt.Printf("数字为: %v; 位数和为: %v\n", v.i, v.ret)
	}
}

func main() {
	x := make(chan *int)
	y := make(chan *ret)

	// 生产者创建随机数, 产生的随机数放入 chan x
	// 1. 产生随机数
	// 2. 支持多个 goroutine 并发
	goStartProducer(2, x)

	// 消费者从 chan x 取出随机数, 计算位数和, 结果放入 chan y 中
	// 1. 支持多个 goroutine 并发
	goStartConsumer(10, x, y)

	// 从 chan2 中取值, 并打印结果
	getRet(y)
}

---

有限数据 – 需要关闭 chan

package main

import (
	"fmt"
	"math/rand"
	"sync"
)

// 放入 chan y 的结构体
type ret struct {
	i   int
	ret int
}

var wg sync.WaitGroup

// 生产者, 产生随机数
func producer(c chan<- *int) {
	defer wg.Done()
	for i := 0; i < 10000; i++ {
		// num := rand.Int() // int 类型的随机数
		num := rand.Intn(100) // 100以内的 int 类型的随机数
		// num := rand.Int31() // int32 个随机数, 类型为 int32, 使用的话需要更改 ret 结构体中 i 的类型
		c <- &num
	}
	close(c)
}

// 开启多少个生产者
func goStartProducer(n int, c chan<- *int) {
	wg.Add(n)
	for i := 0; i < n; i++ {
		go producer(c)
	}
}

// 计算位数和
func calc(i int) int {
	sum := 0

	for i > 0 {
		sum = sum + i%10
		i = i / 10
	}

	return sum
}

// 消费者, 将 chan x 的数字取出, 放入 chan y 中
func consumer(c1 <-chan *int, c2 chan<- *ret) {
	defer wg.Done()
	for v := range c1 {
		vv := *v
		r := calc(vv)
		c2 <- &ret{
			i:   vv,
			ret: r,
		}
	}
}

// 开启多少个消费者
func goStartConsumer(n int, c1 <-chan *int, c2 chan<- *ret) {
	wg.Add(n)
	for i := 0; i < n; i++ {
		go consumer(c1, c2)
	}
}

// 输出位数和的结果
func getRet(c <-chan *ret) {
	for v := range c {
		fmt.Printf("数字为: %v; 位数和为: %v\n", v.i, v.ret)
	}
}

func main() {
	x := make(chan *int)
	// 由于是ret 通道需要串行, 所以需要用有缓存
	y := make(chan *ret, 10000)

	goStartProducer(1, x)
	goStartConsumer(10, x, y)

	// 等待ret 通道中放入数据完成, 关闭通道
	wg.Wait()
	close(y)

	getRet(y)
}