个人对于golang的goroutine并发处理任务时的理解

原文：http://rfyiamcool.blog.51cto.com/1030776/1381686

以前用golang做并发处理的时候，很是粗暴，就是利用golang的高级性能，直接fork一个任务，来处理请求，最典型的就是直接 go func，当时是因为用http和socket没觉得什么，今天再次看golang的goroutine的时候，发现这几天写的程序有些问题。比如用goroutine的时候，同步堵塞。太快了，需要堵堵，不然我没法判断逻辑了。

来个简单的例子：

//xiaorui.ccpackage 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里面代表了通信官的作用。

//xiaorui.ccpackage 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的理解 。

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来解决。

package mainimport (    "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异常的处理。