golang 并发设计模式(一)--资源生成器模式

最新推荐文章于 2025-02-28 14:48:03 发布

千年的塔

最新推荐文章于 2025-02-28 14:48:03 发布

阅读量2.4k

点赞数

分类专栏： golang 并发设计模式

本文链接：https://blog.youkuaiyun.com/hittata/article/details/51777426

版权

golang 并发设计模式专栏收录该内容

7 篇文章

订阅专栏

本文探讨了Go语言中如何利用goroutine实现资源生成器模式，适用于生成订单号、序列号和随机数等场景。通过多路复用技术增强服务处理能力，借助缓冲chan提升效率，并介绍了一种结合并发、缓冲和关闭通知的高级生成器模式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在应用系统中，常见的的应用场景就是调用一个生成器：生成订单号，序列号，随机数等。

golang goroutine为这种需求提供了强大的武器。

1.简单的生成器

package main

import (
		"fmt"
		"math/rand"
)

func GenerateIntA()chan int {
		ch := make(chan int ,10)
		go func(){
		for {
				ch<-rand.Int()
		}
		}()
		return ch
}

func main(){
		ch := GenerateIntA()
		fmt.Println(<-ch)
		fmt.Println(<-ch)
}

2.叠加增强型资源生成器

可以使用多路复用技术进行堆积叠加，增加服务能力
可以使用缓冲chan增加服务能力

package main

import (
	"fmt"
	"math/rand"
)

func GenerateIntA() chan int {
	ch := make(chan int, 10)
	go func() {
		for {
			ch <- rand.Int()
		}
	}()
	return ch
}

func GenerateIntB() chan int {
	ch := make(chan int, 10)
	go func() {
		for {
			ch <- rand.Int()
		}
	}()
	return ch
}

func GenerateInt() chan int {
	ch := make(chan int, 20)
	go func() {
		for {
			select {
			case ch <- <-GenerateIntA():
			case ch <- <-GenerateIntB():
			}
		}
	}()
	return ch
}

func main() {
	ch := GenerateInt()

	for i := 0; i < 100; i++ {
		fmt.Println(<-ch)
	}
}

3.有时我们希望生成器能够自动的退出，这时可以使用golang channel的

Close channel to broadcast 机制实现:

package main

import (
		"fmt"
		"math/rand"
)

func GenerateIntA(done chan struct{})chan int {
		ch := make(chan int )
		go func(){
		Lable:
		for {
				select {
				case ch<-rand.Int():
				case <-done:
						break Lable
		}
		}
		close(ch)
}()
		return ch
}

func main(){
		done :=make(chan struct{})
		ch := GenerateIntA(done)

		fmt.Println(<-ch)
		fmt.Println(<-ch)
		close(done)
		fmt.Println(<-ch)
		fmt.Println(<-ch)
		fmt.Println(<-ch)
		fmt.Println(<-ch)
}

4.可以更牛逼点，既要并发、缓冲，又有通知的生成器：

package main

import (
	"fmt"
	"math/rand"
)

func GenerateIntA(done chan struct{}) chan int {
	ch := make(chan int, 5)

	go func() {
	Lable:
		for {
			select {
			case ch <- rand.Int():
			case <-done:
				break Lable
			}
		}
		close(ch)
	}()
	return ch
}

func GenerateIntB(done chan struct{}) chan int {
	ch := make(chan int, 10)

	go func() {
	Lable:
		for {
			select {
			case ch <- rand.Int():
			case <-done:
				break Lable
			}
		}
		close(ch)
	}()
	return ch
}

func GenerateInt(done chan struct{}) chan int {
	ch := make(chan int)
	send := make(chan struct{})
	go func() {
	Lable:
		for {
			select {
			case ch <- <-GenerateIntA(send):
			case ch <- <-GenerateIntB(send):
			case <-done:
				send <- struct{}{}
				send <- struct{}{}
				break Lable
			}
		}
		close(ch)
	}()
	return ch
}

func main() {
	done := make(chan struct{})
	ch := GenerateInt(done)

	for i := 0; i < 10; i++ {
		fmt.Println(<-ch)
	}
	done <- struct{}{}
	for i := 0; i < 10; i++ {
		v := <-ch
		if v == 0 {
			return
		}
		fmt.Println(<-ch)
	}
}