Goroutines （一）

Goroutines

CSP communicating sequential processes

Go 语言中，每一个并发执行单元叫做一个goroutine，语法上仅需要在一个普通函数或方法调用前加上关键字go。

f() //正常调用

go f() //开启一个goroutine

Channel

一个channel是一个通信机制，它可以让一个goroutine通过它给另一个goroutine发送值信息。每个channel都有一个特殊的类型，也就是channels可发送数据的类型。

ch := make(chan int) // ch has type 'chan int'

ch = make(chan int, 0) // unbuffered channel
ch = make(chan int, 3) // buffered channel with capacity 3

和map类似，channel也对应一个make创建的底层数据结构的引用

当我们复制一个channel或用于函数参数传递时，我们只是拷贝了一个channel引用，因此调用者和被调用者将引用同一个channel对象。和其它的引用类型一样，channel的零值也是nil。
两个相同类型的channel可以使用==运算符比较。如果两个channel引用的是相同的对象，那么比较的结果为真。一个channel也可以和nil进行比较。

ch <- x  // a send statement
x = <-ch // a receive expression in an assignment statement
<-ch     // a receive statement; result is discarded

Channel支持close操作，用于关闭channel，随后对基于该channel的任何发送操作都将导致panic异常。一个已经被close过的channel进行接收操作依然可以接受到之前已经成功发送的数据；如果channel中已经没有数据的话将产生一个零值的数据。

关闭一个channel

close(ch)

不带缓存的Channel

一个基于无缓存Channel的发送操作将导致发送者goroutine阻塞，直到另一个goroutine在相同的Channel上执行接收操作，当发送的值通过Channels成功传输之后，两个goroutine可以继续执行后面的语句。反之，如果接收操作先发生，那么接收者goroutine也将阻塞，直到有另一个goroutine在相同的Channels上执行发送操作。

基于无缓存Channels的发送和接收操作将导致两个goroutine做一次同步操作，因此，无缓存的Channel 也被称为同步Channel ,当通过一个无缓存Channel发送数据时，接收者收到数据发生在再次唤醒发送者goroutine之前(happens before)

消息事件 利用channel进行通信，通知另一个协程事情已经做完

func main() {
	var i = 0
	done := make(chan struct{})
	go func() {
		for i < 10 {
			fmt.Printf("i = %d\n", i)
			i++
			if i == 10 {
				fmt.Printf("done\n")
				done <- struct{}{}
			}
			time.Sleep(100 * time.Millisecond)
		}
	}()
	<-done
}

串联的Channels（Pipeline）

一个Channel的输出作为下一个Channel的输入,当一个channel被关闭后，再向该channel发送数据将导致panic异常。当一个被关闭的channel中已经发送的数据都被成功接收后，后续的接收操作将不再阻塞，它们会立即返回一个零值。

func main() {
	naturals := make(chan int)
	squares := make(chan int)

	// Counter
	go func() {
		for x := 0; ; x++ {
			if x < 100 {
				naturals <- x
			} else {
				close(naturals)
				break // 这里需要break 重复关闭一个channel将导致panic异常
			}
		}
	}()

	// Squarer
	go func() {
		for {
			x := <-naturals
			squares <- x * x
		}
	}()

	// Printer (in main goroutine)
	for {
		fmt.Println(<-squares)
	}
}

x := <-naturals 程序会无休止的收到0值

channel 接收的方式可以改进

利用第二个返回值判断 channel 是否关闭 
go func() {
    for {
        x, ok := <-naturals
        if !ok {
            break 
        }
        squares <- x * x
    }
    close(squares)
}()

l利用for range 形式
for x := range squares {
        fmt.Println(x)
}

试图重复关闭一个channel将导致panic异常，试图关闭一个nil值的channel也将导致panic异常。关闭一个channels还会触发一个广播机制

单方向的Channel

类型chan<- int表示一个只发送int的channel，只能发送不能接收。相反，类型<-chan int表示一个只接收int的channel，只能接收不能发送。

func counter(out chan<- int) {
    for x := 0; x < 100; x++ {
        out <- x
    }
    close(out)
}

func squarer(out chan<- int, in <-chan int) {
    for v := range in {
        out <- v * v
    }
    close(out)
}

func printer(in <-chan int) {
    for v := range in {
        fmt.Println(v)
    }
}

func main() {
    naturals := make(chan int)
    squares := make(chan int)
    go counter(naturals)
    go squarer(squares, naturals)
    printer(squares)
}

带缓存的Channels

ch = make(chan string, 3)

如果channel的内部缓存队列是满的，那么下一个元素发送时将会被阻塞，需要等队列中的元素被消费，如果channel内部缓存队列是空的，那么要消费下一个元素将会被阻塞，需要等待新的元素被送进缓存队列，因此channel的缓存队列解耦了接收和发送的goroutine。

基于select的多路复用

func main() {
    select {
    case <-time.After(10 * time.Second):
        // Do nothing.
    case <-abort:
        return
    }
}

Goroutines和线程

OS线程会被操作系统内核调度，所以从一个线程向另一个切换需要完整的上下文切换，Go的runtime包含了其自己的调度器,rumtime调度不需要进入内核的上下文，所以重新调度一个goroutine比调度一个线程代价要低得多。

GOMAXPROCS

Go的调度器使用了一个叫做GOMAXPROCS的变量来决定会有多少个操作系统的线程同时执行Go的代码。其默认的值是运行机器上的CPU的核心数