Goroutines
goroute是由go运行时管理的轻量级线程
声明
go f(x, y, z)
运行一个新的goroutine
f(x, y, z)
x,y,z在当前goroutine，f在新的goroutine运行。Goroutines共享同一块地址，必须同步访问
package main
import (
"fmt"
"time"
)
func say(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
func main() {
go say("world")
say("hello")
}
// world
// hello
// hello
// world
// world
// hello
// hello
// world
// world
// hello
Channels
Channels是一种管道，通过管道操作符<-发送和接收值
ch <- v // 发送 v 到管道 ch
v := <-ch // 从管道接收值，赋给v
(数据流和箭头方向一致)
构造channel：ch := make(chan int)
在双方准备好前发送方和接收方都会被阻塞，无需显式使用锁(lock)和条件(condition)
package main
import "fmt"
func sum(s []int, c chan int) {
sum := 0
for _, v := range s {
sum += v
}
c <- sum // send sum to c
}
func main() {
s := []int{7, 2, 8, -9, 4, 0}
c := make(chan int)
go sum(s[:len(s)/2], c)
go sum(s[len(s)/2:], c)
x, y := <-c, <-c // receive from c
fmt.Println(x, y, x+y)
}
// -5 17 12
以上将计算分配给两个goroutes
Buffered Channels
管道可以是缓冲区
ch := make(chan int, 100)，初始化大小为100的缓冲区。
缓冲区满时发送到缓冲区被阻塞，缓冲区空时从缓冲区取会被阻塞
package main
import "fmt"
func main() {
ch := make(chan int, 2)
ch <- 1
ch <- 2
fmt.Println(<-ch)
fmt.Println(<-ch)
}
// 1
// 2
Range 和 Close
发送方没有数据发送了可以关闭channel，接收方增加一个参数来检测channel是否关闭
关闭channel：close(c)
v, ok := <-ch
ok为false时chanel已近关闭
for i := range c重复从channel取数据直到它关闭
只有发送方可以关闭channel，如果channel关闭继续发送将引发panic
channel不是文件，一般无需进行关闭，除非需要明确告诉接收方不会有新数据到来，如结束range循环
package main
import (
"fmt"
)
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 main() {
c := make(chan int, 10)
go fibonacci(cap(c), c)
for i := range c {
fmt.Println(i)
}
}
0
// 1
// 1
// 2
// 3
// 5
// 8
// 13
// 21
// 34
Select
select是Go中的一个控制结构，类似于用于通信的switch语句。每个case必须是一个通信操作，要么是发送要么是接收
select随机执行一个可运行的case，如果没有case可运行，它将阻塞，直到有case可运行
package main
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 0, 1
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(<-c)
}
quit <- 0
}()
fibonacci(c, quit)
}
0
// 1
// 1
// 2
// 3
// 5
// 8
// 13
// 21
// 34
// quit
如果没有其他case可以运行，default将会运行
select {
case i := <-c:
// use i
default:
// receiving from c would block
}
package main
import (
"fmt"
"time"
)
func main() {
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)
}
}
}
// .
// .
// tick.
// .
// .
// tick.
// .
// .
// tick.
// .
// .
// tick.
// .
// .
// tick.
// BOOM!
sync.Mutex
用于确保一段时间只有一个goroutine可以访问某个变量
sync.Mutex提供两个方法
Lock
Unlock
package main
import (
"fmt"
"sync"
"time"
)
// SafeCounter is safe to use concurrently.
type SafeCounter struct {
v map[string]int
mux sync.Mutex
}
// Inc increments the counter for the given key.
func (c *SafeCounter) Inc(key string) {
c.mux.Lock()
// Lock so only one goroutine at a time can access the map c.v.
c.v[key]++
c.mux.Unlock()
}
// Value returns the current value of the counter for the given key.
func (c *SafeCounter) Value(key string) int {
c.mux.Lock()
// Lock so only one goroutine at a time can access the map c.v.
defer c.mux.Unlock()
return c.v[key]
}
func main() {
c := SafeCounter{v: make(map[string]int)}
for i := 0; i < 1000; i++ {
go c.Inc("somekey")
}
time.Sleep(time.Second)
fmt.Println(c.Value("somekey"))
}
// 1000
