Go并发编程

package main
import "fmt"
import "sync"
import "runtime"

var counter int = 0
func Count(lock *sync.Mutex) { lock.Lock()
        counter++
        fmt.Println(z)
        lock.Unlock()
}
func main() {
lock := &sync.Mutex{}
   for i := 0; i < 10; i++ { go Count(lock)
}
for { lock.Lock()
c := counter
    lock.Unlock()
runtime.Gosched()
 if c >= 10 {
  } }
}

在上面的例子中,我们在10个goroutine中共享了变量counter。每个goroutine执行完成后, 将counter的值加1。因为10个goroutine是并发执行的,所以我们还引入了锁,也就是代码中的 lock变量。每次对n的操作,都要先将锁锁住,操作完成后,再将锁打开。在主函数中,使用for 循环来不断检查counter的值(同样需要加锁)。当其值达到10时,说明所有goroutine都执行完 毕了,这时主函数返回,程序退出。

事情好像开始变得糟糕了。实现一个如此简单的功能,却写出如此臃肿而且难以理解的代码。 8 想象一下,在一个大的系统中具有无数的锁、无数的共享变量、无数的业务逻辑与错误处理分 支,那将是一场噩梦。这噩梦就是众多C/C++开发者正在经历的,其实Java和C#开发者也好不到 哪里去。

Go语言既然以并发编程作为语言的最核心优势,当然不至于将这样的问题用这么无奈的方式来解决。Go语言提供的是另一种通信模型,即以消息机制而非共享内存作为通信方式。 消息机制认为每个并发单元是自包含的、独立的个体,并且都有自己的变量,但在不同并发 单元间这些变量不共享。每个并发单元的输入和输出只有一种,那就是消息。这有点类似于进程 的概念,每个进程不会被其他进程打扰,它只做好自己的工作就可以了。不同进程间靠消息来通
信,它们不会共享内存。 Go语言提供的消息通信机制被称为channel,接下来我们将介绍下channel的方式。

package main
import "fmt"
func Count(ch chan int) { ch <- 1
        fmt.Println("Counting")
    }
func main() {
chs := make([]chan int, 10) for i := 0; i < 10; i++ {
chs[i] = make(chan int)
go Count(chs[i]) }
for _, ch := range(chs) { <-ch
} 
}

在这个例子中,我们定义了一个包含10个channel的数组(名为chs),并把数组中的每个 channel分配给10个不同的goroutine。在每个goroutine的Add()函数完成后,我们通过ch <- 1语 句向对应的channel中写入一个数据。在这个channel被读取前,这个操作是阻塞的。在所有的 goroutine启动完成后,我们通过<-ch语句从10个channel中依次读取数据。在对应的channel写入 数据前,这个操作也是阻塞的。这样,我们就用channel实现了类似锁的功能,进而保证了所有 goroutine完成后主函数才返回。