o 语言有一个很重要的特性就是 goroutine, 我们可以使用 goroutine 结合 channel 来开发并发程序。
并发程序指的是可以同时运行多个任务的程序，这里的同时运行并不一定指的是同一时刻执行，在单核CPU的机器下，在同一时刻只可能有一个任务在执行，但是由于CPU的速度很快，在不断的切换着多个任务,让它们交替的执行，因此宏观上看起来就像是同时在运行； 而在多核的机器上，并发程序中的多个任务是可以实现在同一时刻执行多个的，此时并发的多个任务是在并行执行的。
goroutine
goroutine 是 go 语言中的并发执行单元，我们可以将多个任务分别放在多个 goroutine 中，来实现并发程序。下面先看一个例子:
package main
import "fmt"
func hello() {
fmt.Println("Hello World!!!")
}
func main() {
go hello()
fmt.Println("Bye!!!")
var input string
fmt.Scanln(&input)
}上述程序的执行结果如下:
Bye!!!
Hello World!!!上面这个例子展示了使用 goroutine 的几个要点:
- 程序启动时，我们的主函数 main 也是在一个单独的 goroutine 中运行的。
go hello()就是用于创建一个 goroutine, 即 go 关键字加上 要在 goroutine 中执行的函数(也可以是匿名函数，不过必须是调用的形式)- 最后两句是用于将 main 函数阻塞在这里,直到我们按下回车键，之所以这么做是因为，我们不知道新创建的 goroutine 和 main goroutine 的执行顺序，有可能主程序先执行完成，此时主程序结束，我们就看不到新 goroutine 的执行效果了。(通常不会使用这种方法)
以上就是 goroutine 的基本用法
channels
前面我们学习了怎样创建并行的执行单元，但是每个执行单元之间是完全独立的，如果我们想在运行期间交换数据，即进行通信，此时就得依靠另一个概念 - channels, 即通道，这个名字十分贴切，就像在不同的并发执行单元之间连接了一根管道，然后通过这跟管道来发送和接收数据。
goroutine 和 channel 经常结合在一起使用，下面学习一些 channel 的用法：
创建 channel
ch1 := make(chan int)channel 也需要使用 make 函数来创建，也就是说 channel 也是一种引用类型(make函数会返回低层数据结构的引用给channel)
向 channel 中读写数据
前面说了 channel 是用于 goroutine 之间通信的, 自然能够从 channel 中写入和读取数据，使用的都是
<-操作符ch := make(chan int) ch<- 1 // 向 channel 中写入数据 var a int = <-ch // 从 channel 中读取数据关闭 channel
在我们使用完一个 channel 之后，可以调用 close() 方法来关闭一个 channel, 关闭之后的通道，不能够再进行数据的写操作, 但是仍然可以读取之前写入成功的数据(如果没有数据了，将返回零值)。
channel 的基本操作就是上面这么多，不过实际上，channel 是有两种的: 无缓冲的 和 有缓冲的。上面我们创建的是无缓存的，有缓存的创建方式是 ch := make(chan int, 2), 二者的区别是:
- 无缓冲的 channel 的发送操作将导致发送者的 goroutine 阻塞，直到在另一个 goroutine 上对其进行接收操作。如果先发生的是接收操作，那么接收者将被阻塞，直到在另一个 goroutine 上对其进行发送操作。
- 带缓存的 channel 可以缓存多个数据，因此不会立即阻塞，只有当缓存满了之后，发送者才可能会被阻塞，并且只有到缓存为空时，接收者才可能被阻塞
例1: 通道用于传递消息
package main
import "fmt"
func main() {
message := make(chan string) // 创建一个用于传递字符串的通道
go func() {
message <- "This is a message." // 向 channel 写入数据
}()
msg := <- message // 从 channel 读取数据
fmt.Println(msg)
}例2: 利用通道进行同步
package main
import "fmt"
func hello() {
fmt.Println("Hello World!!!")
done <- true
}
func main() {
done := make(chan bool)
go hello()
fmt.Println("Bye!!!")
<-done // 这里会阻塞住，直到在另一个 goroutine 中对 done 进行写入操作之后
}单向 channel
当使用 channel 作为参数，我们可以指定 channel 为单向的，即让通道在函数中只能发送，或者只能接收数据，以此来提高程序的安全性.
语法:
<-chan type表示一个只能接收数据的通道chan<- type表示一个只能发送数据的通道
例子:
package main
import "fmt"
// 这里的 message 在函数 send 中就是一个只能发送数据的通道
func send(msg string, message chan<- string) {
message<- msg
}
// 这里的 message 在函数 receive 中就是一个只能发送数据的通道
func receive(message <-chan string) string {
msg := <- message
return msg
}
func main() {
message := make(chan string)
go send("hello", message)
fmt.Println(receive(message))
}输出结果是 hello, 此时在函数 send 中，message 通道就只能用于发送数据，而在函数 receive 中通道只能接收数据，通过参数的限制使其在函数内部成为了单向的通道。
select
go语言提供了一个 select 关键字，可以使用它来等待多个通道的操作，以实现多路复用。语法:
select {
case <-ch1:
...
case ch2 <- value:
...
default:
...
}其中的每个 case 表示一个 channel 的操作，当case语句后面指定通道的操作可以执行时，select 才会执行 case 之后的语句。此时其他的语句都不会被执行。
例子: 超时处理
package main
import "time"
import "fmt"
func main() {
ch1 := make(chan string, 1)
go func() {
time.Sleep(time.Second * 2)
ch1 <- "result 1"
}()
select {
case res := <- ch1:
fmt.Println(res)
case <-time.After(time.Second * 1):
fmt.Println("timeout 1")
}
ch2 := make(chan string, 1)
go func() {
time.Sleep(time.Second * 2)
ch2 <- "result 2"
}()
select {
case res := <-ch2:
fmt.Println(res)
case <-time.After(time.Second * 3):
fmt.Println("timeout 2")
}
}上面的例子中我们定义了两个通道和两个select结构，是为了进行对比，第一个channel会在等待两秒之后被写入数据，而在 select 中，第二个case语句只会等待一秒，然后就会执行，因此就会执行超时操作。而在第二个 select 中，第二个 case 语句会等待三秒。所以上述程序的结果如下:
timeout 1
result 2