以前用golang做并发处理的时候，很是粗暴，就是利用golang的高级性能，直接fork一个任务，来处理请求，最典型的就是直接 go func，当时是因为用http和socket没觉得什么，今天再次看golang的goroutine的时候，发现这几天写的程序有些问题。比如用goroutine的时候，同步堵塞。太快了，需要堵堵，不然我没法判断逻辑了。
原文地址，blog.xiaorui.cc
来个简单的例子：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
//xiaorui.cc package main import ( "fmt" "runtime" "time" ) var a int = 1 func main() { runtime.GOMAXPROCS(runtime.NumCPU()) go sheep(1) // go sheep(2) time.Sleep(time.Millisecond) fmt.Println("end",a) } func sheep(i int) { for ; ; i += 1 { fmt.Println(i, "个屌丝") a+=1 } } |
原文：xiaorui.cc
这个是打印屌丝的数量，golang下的并发直接go 函数就可以了，但是单纯的go的话，他会因为后续的main主函数的任务结束，而结束 。 对于main来说，我已经运行完了，刚才go出去的任务，爱咋咋地。。。 他就这么不负责不管了。 其实这里咱们先不说用golang的解决的方法， 其实可以在结束的时候做个判断，比如每次go完了后，不管成功或者失败都会给一个全局变量加个数或者赋予一个值。 然后再main里面做一个判断，接着是堵塞这个判断，只有if 匹配后，才推出程序。
这个是土方法，其实咱们可以用golang自带的channel，这个东西初级的想法，可以解决上面的问题。 他在golang里面代表了通信官的作用。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//xiaorui.cc package main import ( "fmt" ) var a string var c = make(chan int, 10) func f() { fmt.Println("f 函数运行了") a = "hello, world" c <- 0 } func main() { fmt.Println("先让f这个函数先跑着") go f() <-c fmt.Println("我这里取得了a的值",a) } |
channel有四个操作：
创建：c = make(chan int)
发送：c <- 1
提取：i <- c
关闭：close(c)
里面的10是buffered channels，指定channel的缓冲大小
ch := make(chan type, value)
value == 0 !无缓冲（阻塞）
value > 0 !缓冲（非阻塞，直到value个元素）
大家可以跑跑下面的例子，加深下channel的理解 。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 |
package main import ( "fmt" "time" ) func main() { go say("world") say("hello") fmt.Println("---------------1") a := []int{7, 2, 8, -9, 4, 0} c := make(chan int) go sum(a[:len(a)/2], c) go sum(a[len(a)/2:], c) x, y := <-c, <-c // receive from c fmt.Println(x, y, x+y) fmt.Println("---------------2") c2 := make(chan int, 2) c2 <- 1 c2 <- 2 fmt.Println(<-c2) fmt.Println(<-c2) fmt.Println("---------------3") c3 := make(chan int, 10) go fibonacci(cap(c3), c3) for i := range c3 { fmt.Println(i) } fmt.Println("---------------4") c4 := make(chan int) quit := make(chan int) go func() { for i := 0; i < 10; i++ { fmt.Println(<-c4) } quit <- 0 }() fibonacci2(c4, quit) fmt.Println("---------------5") tick := time.Tick(100 * time.Millisecond) boom := time.After(500 * time.Millisecond) for { select { case <-tick: fmt.Println("tick. ") case <-boom: fmt.Println("BOOM!") return default: fmt.Println(" .") time.Sleep(50 * time.Millisecond) } } } func say(s string) { for i := 0; i < 5; i++ { time.Sleep(100 * time.Millisecond) fmt.Println(s) } } func sum(a []int, c chan int) { sum := 0 for _, v := range a { sum += v } c <- sum // send sum to c } func fibonacci(n int, c chan int) { x, y := 0, 1 for i := 0; i < n; i++ { c <- x x, y = y, x+y } close(c) } func fibonacci2(c, quit chan int) { x, y := 0, 1 for { select { case c <- x: x, y = y, x+y case <-quit: fmt.Println("quit") return } } } |
对于golang的同步问题，不仅可以用channel来解决，也可以用golang的另一个包 sync来解决。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
package main import ( "fmt" "sync" ) func main() { var wg sync.WaitGroup for i := 0; i < 100; i++ { wg.Add(1) } for i := 0; i < 100; i++ { go done(&wg) } wg.Wait() fmt.Println("exit") } func add(wg sync.WaitGroup) { wg.Add(1) } func done(wg *sync.WaitGroup) { wg.Done() } |
sync.WaitGroup只有3个方法，Add()，Done()，Wait()。其中Done()是Add(-1)的别名。简单的来说，使用Add()添加计数，Done()减掉一个计数，计数不为0, 阻塞Wait()的运行。
python下的gevent里面的协程机制和golang差不多的，有时间让他们对比下，看看gevent比golang的goroutine相差有多少。
遇到的问题，这个是因为本身网络就不稳定引起的，为了更友好的显示数据，需要做好更好的defer异常的处理。
有疑问加站长微信联系（非本文作者）
