[练习]go版的击鼓传花

laputa73

这个是erlang的一个练习.从前有人用来展现stackelss python的性能如何牛.
学习go的goroutine,也照猫画虎来一个.
go的协程有些特别.没有join等待协程结束,所以用了一个结果队列(类似perl)
channel的写入默认也是非缓冲(阻塞方式)的
总体来看,go的协程性能相当之好,即使是go run方式,类似脚本运行,也比python,perl快不少

编程的风格和c很象
数组作为函数参数,这块没有具体研究是传值还是传指针
想当然地按c的方式处理了

1. /*
   
2. go版的击鼓传花（erlang和stackless的经典例子）
   
3. 由n个节点组成一个环状网络，在上面传送共m个消息。
   
4. 将每个消息（共m个），逐个发送给1号节点。
   
5. 第1到n-1号节点在接收到消息后，都转发给下一号节点。
   
6. 第n号节点每次收到消息后，不再继续转发。
   
7. 当m个消息都从1号逐个到达第n号节点时，认为全部处理结束。
   
8. 每次执行时设定n=300，m=10000
   
9. */
   
10. package main
    
11. import (
    
12. "flag"
    
13. "fmt"
    
14. //"os"
    
15. "strconv"
    
16. )
    
17. 
    
18. var n,m int
    
19. 
    
20. //3.定义节点(协程)
    
21. func node(i int,ch []chan int,result chan int){
    
22.         for{
    
23.                 msg:= <-ch[i]
    
24.                 //fmt.Println("node ", i," got msg ",msg)
    
25.                 if i>=n-1 {
    
26.                         //fmt.Println("msg ", msg," reached last node ",i)
    
27.                         if msg>=m-1 {
    
28.                                 fmt.Println("final msg send back")
    
29.                                 result <- msg
    
30.                         }
    
31.                 }else{
    
32.                         //fmt.Println("node ", i," pass msg  ",msg," to next node")
    
33.                         ch[i+1] <- msg
    
34.                 }
    
35.         }
    
36. }
    
37. 
    
38. func main() {
    
39.         //1.输入参数处理
    
40.         flag.Parse()
    
41.         args := flag.Args()
    
42.         if args != nil&&len(args) > 0 {
    
43.                 var err error
    
44.                 n,err = strconv.Atoi(args[0])
    
45.                 if err != nil {
    
46.                         n = 300
    
47.                 }
    
48.                 m,err = strconv.Atoi(args[1])
    
49.                 if err != nil {
    
50.                         m = 10000
    
51.                 }
    
52.         } else {
    
53.                 n = 300
    
54.                 m=10000
    
55.         }
    
56.         fmt.Println("n=", n,"m=",m)
    
57.        
    
58.         //2.创建队列/channel
    
59.         //用于结束.go没有join之类的等待同步函数
    
60.         result := make(chan int)
    
61.         chs := make([]chan int,n)
    
62.         for i := 0; i < n; i++ {
    
63.                 chs[i] = make(chan int)
    
64.                 //5.启动节点(创建协程)
    
65.                 go node(i,chs,result)
    
66.         }
    
67.        
    
68.        
    
69. 
    
70.   //4.初始化消息
    
71.   //go的channel写也是阻塞的
    
72.   for i := 0; i < m; i++ {
    
73.           //fmt.Println("put msg ", i," into  channel 0")
    
74.           chs[0] <- i
    
75.   }
    
76.   
    
77.   //等待结束
    
78.   <-result
    
79. }
    
80. 
    
81. //测试结果
    
82. 
    
83. /*
    
84. 192.168.6.150
    
85. -bash-3.2$ go build ring.go
    
86. -bash-3.2$ time ./ring 3000 100
    
87. n= 3000 m= 100
    
88. final msg send back
    
89. 
    
90. real    0m0.356s
    
91. user    0m0.229s
    
92. sys     0m0.020s
    
93. -bash-3.2$ time go run ./ring.go 3000 100
    
94. n= 3000 m= 100
    
95. final msg send back
    
96. 
    
97. real    0m0.919s
    
98. user    0m0.631s
    
99. sys     0m0.079s
    
100. -bash-3.2$
     
101. -bash-3.2$ time ./ring 10000 100
     
102. n= 10000 m= 100
     
103. final msg send back
     
104. 
     
105. real    0m1.113s
     
106. user    0m0.774s
     
107. sys     0m0.038s
     
108. -bash-3.2$ time go run ./ring.go 10000 100
     
109. n= 10000 m= 100
     
110. final msg send back
     
111. 
     
112. real    0m1.747s
     
113. user    0m1.276s
     
114. sys     0m0.093s
     
115. 
     
116. -bash-3.2$ time ./ring 100 10000
     
117. n= 100 m= 10000
     
118. final msg send back
     
119. 
     
120. real    0m0.692s
     
121. user    0m0.493s
     
122. sys     0m0.004s
     
123. -bash-3.2$
     
124. -bash-3.2$ time go run ./ring.go 100 10000
     
125. n= 100 m= 10000
     
126. final msg send back
     
127. 
     
128. real    0m1.329s
     
129. user    0m0.903s
     
130. sys     0m0.074s
     
131. -bash-3.2$
     
132. -bash-3.2$ time go run ./ring.go 300 10000
     
133. n= 300 m= 10000
     
134. final msg send back
     
135. 
     
136. real    0m2.628s
     
137. user    0m1.924s
     
138. sys     0m0.073s
     
139. -bash-3.2$ time ./ring 300 10000
     
140. n= 300 m= 10000
     
141. final msg send back
     
142. 
     
143. real    0m1.922s
     
144. user    0m1.505s
     
145. sys     0m0.018s
     
146. 
     
147. */

复制代码