goroutine(协程)
大家都知道java中的线程Thread，golang没有提供Thread的功能，但是提供了更轻量级的goroutine(协程)，协程比线程更轻，创办一个协程很简单，只需要go关键字加上要运行的函数，就可以实现了。看个简单的例子：
package main import "fmt" func f(from string) { for i := 0; i < 3; i++ { fmt.Println(from, ":", i) } } func main() { f("direct") go f("goroutine") go func(msg string) { fmt.Println(msg) }("going") fmt.Scanln() fmt.Println("done") }
运行结果如下：
direct : 0 direct : 1 direct : 2 goroutine : 0 going goroutine : 1 goroutine : 2 <enter> done
Channels(信道)
channels是并发的goroutines之间通信的管道，我们可以从一个goroutine输出一条数据到一个channel，然后用另外一个goroutine读取，这就实现了goroutines之间的通信。下面的例子演示的是主goroutine与另一个goroutine之间的通信：
package main import "fmt" func main() { messages := make(chan string) go func() { messages <- "ping" }() msg := <-messages fmt.Println(msg) }
channel buffer
channel的默认空间是0，如果向一个默认长度的channel输入一条数据，程序就会阻塞，直到这条数据被读出。但是我们可以在定义channel时设置其buffer的大小，比如:
messages := make(chan string, 2)
上边这条语句定义的channel的缓存大小为2，当输入小于等于2条数据时，程序不会阻塞，但是当输入第三条数据时就会阻塞，直到被读出一条。
channel Synchronization
所谓channel Synchronization，其实就是利用channel的阻塞机制，当想让程序阻塞时，就向一个buffer为0的channel send一条数据，程序就会阻塞从而锁住，当想解锁时，就再把这个channel中的数据输出就ok了
package main import "fmt" import "time" func worker(done chan bool) { fmt.Print("working...") time.Sleep(time.Second) fmt.Println("done") done <- true } func main() { done := make(chan bool, 1) go worker(done) <-done }
channel方向
所谓channel方向，其实指的就是该channel是允许信息输入，还是允许信息输出，普通的channel是既可以输入，也可以输出的，但是我们可以通过设置，让之称为单向的channel，语句如下：
只允许输出 ： pings <-chan string
只允许输入 ： pongs chan<- string
其实很easy，就是在定义的时候在chan关键字的前方或者后方加上“<-”即可，下面看一个相关的demo
package main import "fmt" func ping(pings chan<- string, msg string) { pings <- msg } func pong(pings <-chan string, pongs chan<- string) { msg := <-pings pongs <- msg } func main() { pings := make(chan string, 1) pongs := make(chan string, 1) ping(pings, "passed message") pong(pings, pongs) fmt.Println(<-pongs) }
select
在多goroutine多channel情况下，我们不知道哪个goroutine的channel会先结束阻塞状体，我们通过select同时等待多个channel，类似于监听，然后当任何一个channel有消息传出的时候，就会类似于switch case的触发机制一样选择相应的channel读取消息，如果同时有多个消息到达，那么就会随机从一个channel读取消息，如果一直没有消息送到，select会一直阻塞。
package main import "time" import "fmt" func main() { c1 := make(chan string) c2 := make(chan string) go func() { time.Sleep(1 * time.Second) c1 <- "one" }() go func() { time.Sleep(2 * time.Second) c2 <- "two" }() for i := 0; i < 2; i++ { select { case msg1 := <-c1: fmt.Println("received", msg1) case msg2 := <-c2: fmt.Println("received", msg2) } } }
Timeout机制
上边的select功能，如果channel种一直没有消息传出呢，那么select就会一直阻塞，在大多数情况下这不是我们的期望，我们希望有一个阈值，过了这个阈值大小我们可以让select解除阻塞，我们就可以通过timeout机制来对这种情况进行设置。
package main import "time" import "fmt" func main() { c1 := make(chan string, 1) go func() { time.Sleep(2 * time.Second) c1 <- "result 1" }() select { case res := <-c1: fmt.Println(res) case <-time.After(1 * time.Second): fmt.Println("timeout 1") } c2 := make(chan string, 1) go func() { time.Sleep(2 * time.Second) c2 <- "result 2" }() select { case res := <-c2: fmt.Println(res) case <-time.After(3 * time.Second): fmt.Println("timeout 2") } }
Non-Blocking Channel Operations
上面我们知道了对select设置最长阻塞时间，那么现在我们设置让其不阻塞，只需要在select中添加一个default即可
package main import "fmt" func main() { messages := make(chan string) signals := make(chan bool) select { case msg := <-messages: fmt.Println("received message", msg) default: fmt.Println("no message received") } msg := "hi" select { case messages <- msg: fmt.Println("sent message", msg) default: fmt.Println("no message sent") } select { case msg := <-messages: fmt.Println("received message", msg) case sig := <-signals: fmt.Println("received signal", sig) default: fmt.Println("no activity") } }
Closing channel
如果把一个channel close掉，那么就不能向这个channel插入数据，我们可以视为对这个channel的输入任务已经完成，代码如下：
package main import "fmt" func main() { jobs := make(chan int, 5) done := make(chan bool) go func() { for { j, more := <-jobs if more { fmt.Println("received job", j) } else { fmt.Println("received all jobs") done <- true return } } }() for j := 1; j <= 3; j++ { jobs <- j fmt.Println("sent job", j) } close(jobs) fmt.Println("sent all jobs") <-done }
range over channel
在前面的例子里，我们知道，range可以对基本的数据结构进行遍历，channel也可以通过range进行遍历
package main import "fmt" func main() { queue := make(chan string, 2) queue <- "one" queue <- "two" close(queue) for elem := range queue { fmt.Println(elem) } }
timer and tickers
sleep功能都知道，如果我们想在将来某个时间点执行一个语句，或者每1分钟执行一次某函数，怎么办呢，timer和ticker就能完美解决需求。timer可以设置时间间隔大小，让某个语句到timer所设置的时间间隔后执行，之所以有了sleep还用timer，就是因为timer设置的时间间隔可以提前强制stop掉，如下代码：
package main import "time" import "fmt" func main() { timer1 := time.NewTimer(2 * time.Second) <-timer1.C fmt.Println("Timer 1 expired") timer2 := time.NewTimer(time.Second) go func() { <-timer2.C fmt.Println("Timer 2 expired") }() stop2 := timer2.Stop() if stop2 { fmt.Println("Timer 2 stopped") } }
输出结果：
Timer 1 expired
Timer 2 stopped
因为主协程和go启动的func匿名函数相当于两个协程，所以，主协程中输出正确，但是timer2却没有正确输出，就是因为在主协程中通过timer2.stop()停止了timer2的计时等待，于是主协程先跑完了，并没有跑到另外一个协程。（ps 如果不设置等待，其他协程都不会执行，因为主协程会先跑完然后整个程序就跑完了，其他协程根本来不及跑）
tickers是设置心跳机制，先看一段代码：
ackage main import "time" import "fmt" func main() { // Tickers use a similar mechanism to timers: a // channel that is sent values. Here we'll use the // `range` builtin on the channel to iterate over // the values as they arrive every 500ms. ticker := time.NewTicker(500 * time.Millisecond) go func() { for t := range ticker.C { fmt.Println("Tick at", t) } }() // Tickers can be stopped like timers. Once a ticker // is stopped it won't receive any more values on its // channel. We'll stop ours after 1600ms. time.Sleep(1600 * time.Millisecond) ticker.Stop() fmt.Println("Ticker stopped") }
类似于一个定时器，可以这样理解：ticker.C是一个特别的channel，这里设置的是每500ms就把当前时间输入到这个channel中去，程序通过go关键字启动了一个新的协程，然后通过for循环读出时间并输出，但是读出来后channel中就没有数据了，会阻塞，知道500ms后程序又自动填充一条时间数据进去，阻塞结束，继续循环，直到主协程结束。
Worker Pools的实现
假设有3个人，同时有5份工作，给三个人分配工作随机，但有一个要求，只有完成了手头工作，才能接下一个，实现代码如下：
package main import "fmt" import "time" func worker(id int, jobs <-chan int, results chan<- int) { for j := range jobs { fmt.Println("worker", id, "started job", j) time.Sleep(time.Second) fmt.Println("worker", id, "finished job", j) results <- j * 2 } } func main() { jobs := make(chan int, 100) results := make(chan int, 100) for w := 1; w <= 3; w++ { go worker(w, jobs, results) } for j := 1; j <= 5; j++ { jobs <- j } close(jobs) for a := 1; a <= 5; a++ { <-results } }
由于协程和线程的运行特性一样，是无序的，所以每一次的输出结果都是不同的，下面是某次输出：
worker 1 started job 1 worker 2 started job 2 worker 3 started job 3 worker 1 finished job 1 worker 1 started job 4 worker 2 finished job 2 worker 2 started job 5 worker 3 finished job 3 worker 1 finished job 4 worker 2 finished job 5
rate limit
go优雅的支持对运行程序的速度限制，通过time.Tick()和channel的阻塞特性，类似于ticker一样对程序限速，如下：
package main import "time" import "fmt" func main() { // First we'll look at basic rate limiting. Suppose // we want to limit our handling of incoming requests. // We'll serve these requests off a channel of the // same name. requests := make(chan int, 5) for i := 1; i <= 5; i++ { requests <- i } close(requests) // This `limiter` channel will receive a value // every 200 milliseconds. This is the regulator in // our rate limiting scheme. limiter := time.Tick(200 * time.Millisecond) // By blocking on a receive from the `limiter` channel // before serving each request, we limit ourselves to // 1 request every 200 milliseconds. for req := range requests { <-limiter fmt.Println("request", req, time.Now()) } // We may want to allow short bursts of requests in // our rate limiting scheme while preserving the // overall rate limit. We can accomplish this by // buffering our limiter channel. This `burstyLimiter` // channel will allow bursts of up to 3 events. burstyLimiter := make(chan time.Time, 3) // Fill up the channel to represent allowed bursting. for i := 0; i < 3; i++ { burstyLimiter <- time.Now() } // Every 200 milliseconds we'll try to add a new // value to `burstyLimiter`, up to its limit of 3. go func() { for t := range time.Tick(200 * time.Millisecond) { burstyLimiter <- t } }() // Now simulate 5 more incoming requests. The first // 3 of these will benefit from the burst capability // of `burstyLimiter`. burstyRequests := make(chan int, 5) for i := 1; i <= 5; i++ { burstyRequests <- i } close(burstyRequests) for req := range burstyRequests { <-burstyLimiter fmt.Println("request", req, time.Now()) } }
自此，我自学的golang的goroutine和channel的特性就介绍完了，欢迎批评指正，互相学习。