1.简单的生成器

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

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

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

Close channel to broadcast 机制实现:

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

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