golang 学习 ---- channel

把一个loop放在一个goroutine里跑，咱们可使用关键字go来定义并启动一个goroutine:

package main

import "fmt"

func loop() {
	for i := 0; i < 10; i++ {
		fmt.Printf("%d ", i)
	}
}

func main() {
	go loop() // 启动一个goroutine
	loop()
}

输出:

0 1 2 3 4 5 6 7 8 9

　

但是为何只输出了一趟呢？明明咱们主线跑了一趟，也开了一个goroutine来跑一趟啊。

原来，在goroutine还没来得及跑loop的时候，主函数已经退出了。

main函数退出地太快了，咱们要想办法阻止它过早地退出，一个办法是让main等待一下:

package main

import (
	"fmt"
	"time"
)

func loop() {
	for i := 0; i < 10; i++ {
		fmt.Printf("%d ", i)
	}
}

func main() {
	go loop() // 启动一个goroutine
	loop()
	time.Sleep(time.Second)
}

　　

但是采用等待的办法并很差，若是goroutine在结束的时候，告诉下主线说“Hey, 我要跑完了！”就行了， 即所谓阻塞主线的办法，回忆下咱们Python里面等待全部线程执行完毕的写法:

for thread in threads:
    thread.join()

　　

是的，咱们也须要一个相似join的东西来阻塞住主线。那就是信道(channel)

channel是goroutine之间互相通信的东西。相似咱们Unix上的管道（能够在进程间传递消息）， 用来goroutine之间发消息和接收消息。其实，就是在作goroutine之间的内存共享。

使用make来创建一个信道:

var channel chan int = make(chan int)
// 或
channel := make(chan int)

　　

那如何向信道存消息和取消息呢？ 一个例子:

package main

import (
	"fmt"
)

func main() {
	var msg chan string = make(chan string)//无缓冲channel
	go func(message string) {
		msg <- message // 存消息
	}("Ping!")

	fmt.Println(<-msg) // 取消息
}

　　

默认的，信道的存消息和取消息都是阻塞的 (叫作无缓冲的信道，不过缓冲这个概念稍后了解，先说阻塞的问题)。

也就是说, 无缓冲的信道在取消息和存消息的时候都会挂起当前的goroutine，除非另外一端已经准备好。

好比如下的main函数和foo函数:

package main

var ch chan int = make(chan int)

func foo() {
    ch <- 0  // 向ch中加数据，若是没有其余goroutine来取走这个数据，那么挂起foo, 直到main函数把0这个数据拿走
}

func main() {
    go foo()
    <- ch // 从ch取数据，若是ch中还没放数据，那就挂起main线，直到foo函数中放数据为止
}

那既然信道能够阻塞当前的goroutine, 那么回到上一部分「goroutine」所遇到的问题「如何让goroutine告诉主线我执行完毕了」 的问题来, 使用一个信道来告诉主线便可:

package main

import "fmt"

var complete chan int = make(chan int)

func loop() {
	for i := 0; i < 10; i++ {
		fmt.Printf("%d ", i)
	}

	complete <- 0 // 执行完毕了，发个消息
}

func main() {
	go loop()
	<-complete // 直到线程跑完, 取到消息. main在此阻塞住
}

　　

若是不用信道来阻塞主线的话，主线就会过早跑完，loop线都没有机会执行、、、

其实，无缓冲的信道永远不会存储数据，只负责数据的流通，为何这么讲呢？

• 从无缓冲信道取数据，必需要有数据流进来才能够，不然当前线阻塞

• 数据流入无缓冲信道, 若是没有其余goroutine来拿走这个数据，那么当前线阻塞

因此，你能够测试下，不管如何，咱们测试到的无缓冲信道的大小都是0 (len(channel))

若是信道正有数据在流动，咱们还要加入数据，或者信道干涩，咱们一直向无数据流入的空信道取数据呢？ 就会引发死锁

死锁

一个死锁的例子:

package main

func main() {
	ch := make(chan int)
	<-ch // 阻塞main goroutine, 信道c被锁
}

执行这个程序你会看到Go报这样的错误:

fatal error: all goroutines are asleep - deadlock!

何谓死锁? 操做系统有讲过的，全部的线程或进程都在等待资源的释放。如上的程序中, 只有一个goroutine, 因此当你向里面加数据或者存数据的话，都会锁死信道， 而且阻塞当前 goroutine, 也就是全部的goroutine(其实就main线一个)都在等待信道的开放(没人拿走数据信道是不会开放的)，也就是死锁咯。

我发现死锁是一个颇有意思的话题，这里有几个死锁的例子:

只在单一的goroutine里操做无缓冲信道，必定死锁。好比你只在main函数里操做信道:

package main

import "fmt"

func main() {
	ch := make(chan int)
	ch <- 1                                // 1流入信道，堵塞当前线, 没人取走数据信道不会打开
	fmt.Println("This line code wont run") //在此行执行以前Go就会报死锁
}

主线等ch1中的数据流出，ch1等ch2的数据流出，可是ch2等待数据流入，两个goroutine都在等，也就是死锁

package main

import "fmt"

var ch1 chan int = make(chan int)
var ch2 chan int = make(chan int)

func say(s string) {
	fmt.Println(s)
	ch1 <- <-ch2 // ch1 等待 ch2流出的数据
}

func main() {
	go say("hello")
	<-ch1 // 堵塞主线
}

　　总结来看，为何会死锁？非缓冲信道上若是发生了流入无流出，或者流出无流入，也就致使了死锁。或者这样理解 Go启动的全部goroutine里的非缓冲信道必定要一个线里存数据，一个线里取数据，要成对才行 。因此下面的示例必定死锁:

package main

func main() {
	c, quit := make(chan int), make(chan int)

	go func() {
		c <- 1    // c通道的数据没有被其余goroutine读取走，堵塞当前goroutine
		quit <- 0 // quit始终没有办法写入数据
	}()

	<-quit // quit 等待数据的写
}

　　仔细分析的话，是因为：主线等待quit信道的数据流出，quit等待数据写入，而func被c通道堵塞，全部goroutine都在等，因此死锁。

修正死锁

package main

func main() {
	c, quit := make(chan int), make(chan int)

	go func() {
		c <- 1    // c通道的数据没有被其余goroutine读取走，堵塞当前goroutine
		quit <- 0 // quit始终没有办法写入数据
	}()

	go func() {
		<-c
		<-quit
	}()

}

　　

给channel增长缓冲区，而后在程序的最后让主线程休眠一秒，代码以下：

package main

import (
	"fmt"
	"time"
)

func main() {
	ch := make(chan int, 1)
	ch <- 1
	go func() {
		v := <-ch
		fmt.Println(v)
	}()
	time.Sleep(1 * time.Second)
	fmt.Println("2")

}