go并发设计模式 --资源生成器模式

1.简单的生成器

1. package main
2. import (
3. "fmt"
4. "math/rand"
5. )
6. func GenerateIntA()chan int {
7. ch := make(chan int ,10)
8. go func(){
9. for {
10. ch<-rand.Int()
11. }
12. }()
13. return ch
14. }
15. func main(){
16. ch := GenerateIntA()
17. fmt.Println(<-ch)
18. fmt.Println(<-ch)
19. }

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

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

1. package main
2. import (
3. "fmt"
4. "math/rand"
5. )
6. func GenerateIntA() chan int {
7. ch := make(chan int, 10)
8. go func() {
9. for {
10. ch <- rand.Int()
11. }
12. }()
13. return ch
14. }
15. func GenerateIntB() chan int {
16. ch := make(chan int, 10)
17. go func() {
18. for {
19. ch <- rand.Int()
20. }
21. }()
22. return ch
23. }
24. func GenerateInt() chan int {
25. ch := make(chan int, 20)
26. go func() {
27. for {
28. select {
29. case ch <- <-GenerateIntA():
30. case ch <- <-GenerateIntB():
31. }
32. }
33. }()
34. return ch
35. }
36. func main() {
37. ch := GenerateInt()
38. for i := 0; i < 100; i++ {
39. fmt.Println(<-ch)
40. }
41. }

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

Close channel to broadcast 机制实现:

1. package main
2. import (
3. "fmt"
4. "math/rand"
5. )
6. func GenerateIntA(done chan struct{})chan int {
7. ch := make(chan int )
8. go func(){
9. Lable:
10. for {
11. select {
12. case ch<-rand.Int():
13. case <-done:
14. break Lable
15. }
16. }
17. close(ch)
18. }()
19. return ch
20. }
21. func main(){
22. done :=make(chan struct{})
23. ch := GenerateIntA(done)
24. fmt.Println(<-ch)
25. fmt.Println(<-ch)
26. close(done)
27. fmt.Println(<-ch)
28. fmt.Println(<-ch)
29. fmt.Println(<-ch)
30. fmt.Println(<-ch)
31. }

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

1. package main
2. import (
3. "fmt"
4. "math/rand"
5. )
6. func GenerateIntA(done chan struct{}) chan int {
7. ch := make(chan int, 5)
8. go func() {
9. Lable:
10. for {
11. select {
12. case ch <- rand.Int():
13. case <-done:
14. break Lable
15. }
16. }
17. close(ch)
18. }()
19. return ch
20. }
21. func GenerateIntB(done chan struct{}) chan int {
22. ch := make(chan int, 10)
23. go func() {
24. Lable:
25. for {
26. select {
27. case ch <- rand.Int():
28. case <-done:
29. break Lable
30. }
31. }
32. close(ch)
33. }()
34. return ch
35. }
36. func GenerateInt(done chan struct{}) chan int {
37. ch := make(chan int)
38. send := make(chan struct{})
39. go func() {
40. Lable:
41. for {
42. select {
43. case ch <- <-GenerateIntA(send):
44. case ch <- <-GenerateIntB(send):
45. case <-done:
46. send <- struct{}{}
47. send <- struct{}{}
48. break Lable
49. }
50. }
51. close(ch)
52. }()
53. return ch
54. }
55. func main() {
56. done := make(chan struct{})
57. ch := GenerateInt(done)
58. for i := 0; i < 10; i++ {
59. fmt.Println(<-ch)
60. }
61. done <- struct{}{}
62. for i := 0; i < 10; i++ {
63. v := <-ch
64. if v == 0 {
65. return
66. }
67. fmt.Println(<-ch)
68. }
69. }