阅读Go语言官方博客系列

Go语言并发模式

这是阅读Go语言官方博客系列的第一篇文章。Go语言官方的内容特别多，并且很有指向性的解决了我们遇到的大多数问题。
本文的内容是上个月在油管看了一个2012年的 Go 团队在 Google I/O 的演讲视频，然后在B站找到了这个视频的熟肉。有趣的是我截屏整理后才发现官方公布了 幻灯片。

另外，本文仅做整理，无教程性内容。

好了，让我们进入正题。

资料搜集

原视频是英文演讲。

B站的视频是国内 Up 主 Capricornwqh上传的熟肉。

幻灯片是 Go 语言官方，在 go-blog 发布的 slide。

• 原视频 ： Google I/O 2012 - Go Concurrency Patterns - YouTube（需科学上网）

• 国内翻译视频：Go Concurrency Patterns 中文字幕 bilibili

• 幻灯片：Go Concurrency Patterns-concurrency.slide（需科学上网）

幻灯片截屏整理

（多图预警）

代码整理

幻灯片结束之后，我们来整理代码

demo01

// demo01: 	package mainimport ("math/rand""fmt""time"
)func main() {boring("boring!")
}func boring(msg string) {for i := 0; ; i++ {fmt.Println(msg, i)time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)}
}

demo02

// demo02
package mainimport ("fmt""time""math/rand"
)func main()  {go boring("boring!")
}func boring(msg string)  {for i := 0; ; i++ {fmt.Println(msg, i)time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)}
}

demo03

// demo03
package mainimport ("fmt""math/rand""time"
)func main() {go boring("boring!")fmt.Println("I`m Listening...")time.Sleep(2 * time.Second)fmt.Println("You are boring! I`m leaving!")}func boring(msg string) {for i := 0; ; i++ {fmt.Println(msg, i)time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)}
}

demo04

// demo04
// Using channels// An aside about buffered channels// Note for exports: Go channels can also be created with a buffer.
// Buffering removes synchronization.
// Buffering makes them more like Erlang`s mailboxes.
// Buffered channels can be important for some problems 
// but they are more subtle to reason about
// We won`t need them today.// The Go approach
// Don`t communicate by sharing memory, sharing memory by communicating.
// 不要使用内存共享的方式通信，使用通信来完成内存共享。package mainimport ("fmt""time""math/rand"
)func main()  {c := make(chan, string)go boring("boring!", c)for i := 0; i < 5; i++ {fmt.Printf("You say: %q\n", <-c)}fmt.Println("You are boring! I`m leaving!")
}func boring(msg string, c chan string) {for i := 0; ; i++ {c <- fmt.Sprint("%s %d", msg, i)time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)}
}

demo05

// demo05
// Generator: function that returns a channel
// Channels are first-class values, just like strings or integers.package mainimport ("fmt""math/rand""time"
)func main() {c := boring("boring!")for i := 0; i < 5; i++ {fmt.Printf("You say: %q\n", <-c)}fmt.Println("You are boring! I`m leaving!")
}func boring(msg string) <-chan string {c := make(chan string)go func() {for i := 0; ; i++ {c <- fmt.Sprintf("%s %d", msg, i)time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)}}()return c
}

demo06

// demo06
// Channels as a handle on service// Our boring function returns a channel that let us communicate with the boring service it provides.
package mainimport ("fmt""math/rand""time"
)func main() {joe := boring("Joe")ann := boring("Ann")for i := 0; i < 5; i++ {fmt.Println(<-joe)fmt.Println(<-ann)}fmt.Println("You are boring! I`m leaving!")
}func boring(msg string) <-chan string {c := make(chan string)go func() {for i := 0; ; i++ {c <- fmt.Sprintf("%s %d", msg, i)time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)}}()return c
}

demo07

// demo 07
// Multiplexingpackage mainimport "fmt"func main() {c := fanIn(boring("Joe"), boring("Ann"))for i := 0; i < 10; i++ {fmt.Println(<-c)}fmt.Println("You`re both boring; I`m leaving")
}// fanIn
// input1\input2是两个仅接收channel
// fanIn 返回值也是一个仅接受Channel
// 拿出 仅接受Channel 的值 的方法是  <-[仅接收channel变量名]
func fanIn(input1, input2 <-chan string) <-chan string {fmt.Printf("input 1:%v \nInput2: %v\n", input1, input2)c := make(chan string)go func() {for {c <- <-input1}}()go func() {for {c <- <-input2}}()return c
}func boring(msg string) <-chan string {c := make(chan string)go func() {for i := 0; ; i++ {c <- fmt.Sprintf("%s %d", msg, i)}}()return c
}

demo08

// demo08
// Reastoring sequencing
package mainimport ("fmt""math/rand""time"
)// Message msg wait
type Message struct {msg  stringwait chan bool
}func fanIn(input1, input2 <-chan Message) <-chan Message {fmt.Printf("input 1:%v \nInput2: %v\n", input1, input2)c := make(chan Message)go func() {for {c <- <-input1}}()go func() {for {c <- <-input2}}()return c
}func boring(msg string) <-chan Message {c := make(chan Message)waitFor := make(chan bool)go func() {for i := 0; ; i++ {c <- Message{fmt.Sprintf("%s,%d", msg, i), waitFor}time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)<-waitFor}}()return c
}func main() {c := fanIn(boring("Joe"), boring("Ann"))for i := 0; i < 5; i++ {msg1 := <-cfmt.Println(msg1.msg)msg2 := <-cfmt.Println(msg2.msg)msg1.wait <- truemsg2.wait <- true}fmt.Println("You`re both boring; I`m leaving")}

demo09

// demo09
// Fan-in using select// Rewrite our original fanIn function.
// Only one goroutine is needed.package mainimport ("fmt""math/rand""time"
)// Message msg wait
type Message struct {msg  stringwait chan bool
}func fanIn(input1, input2 <-chan Message) <-chan Message {fmt.Printf("input 1:%v \nInput2: %v\n", input1, input2)c := make(chan Message)go func() {for {select {case s := <-input1:c <- scase s := <-input2:c <- s}}}()return c
}func boring(msg string) <-chan Message {c := make(chan Message)waitFor := make(chan bool)go func() {for i := 0; ; i++ {c <- Message{fmt.Sprintf("%s,%d", msg, i), waitFor}time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)<-waitFor}}()return c
}func main() {c := fanIn(boring("Joe"), boring("Ann"))for i := 0; i < 5; i++ {msg1 := <-cfmt.Println(msg1.msg)msg2 := <-cfmt.Println(msg2.msg)msg1.wait <- truemsg2.wait <- true}fmt.Println("You`re both boring; I`m leaving")}

demo10

// demo10
// Timeout using select// The time.After function returns a channel that blocks
// for the specified duration.
// After the interval, the channel delivers the current time, once.
package mainimport ("fmt""math/rand""time"
)func boring(msg string) <-chan string {c := make(chan string)go func() {for i := 0; ; i++ {c <- fmt.Sprintf("%s: %d", msg, i)time.Sleep(time.Duration(rand.Intn(1020)) * time.Millisecond)}}()return c
}func main() {c := boring("Joe")for {select {case s := <-c:fmt.Println(s)case <-time.After(1 * time.Second):fmt.Println("You`re too slow...")return}}
}

demo11

// demo11
// Timeout for whole conversation using select// Create the timer once, outside the loop, to time out the entire conversation.
// (In the previous program, we had a timeout for each message.)
package mainimport ("fmt""math/rand""time"
)func boring(msg string) <-chan string {c := make(chan string)go func() {for i := 0; ; i++ {c <- fmt.Sprintf("%s: %d", msg, i)time.Sleep(time.Duration(rand.Intn(1020)) * time.Millisecond)}}()return c
}func main() {c := boring("Joe")timeout := time.After(3 * time.Second)for {select {case s := <-c:fmt.Println(s)case <-timeout:fmt.Println("You`re too slow...")return}}
}

demo12

// demo12
// Qiut Channelpackage mainimport ("fmt""math/rand""time"
)func boring(msg string, quit chan bool) <-chan string {c := make(chan string)go func() {for i := 0; ; i++ {select {case c <- fmt.Sprintf("%s: %d", msg, i):// do nothingcase <-quit:fmt.Println("Oh! You Stop Me!")return}time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)}}()return c
}func main() {quit := make(chan bool)c := boring("Joe", quit)for i := rand.Intn(10); i >= 0; i-- {fmt.Println(<-c)}quit <- true
}

demo13

// demo13
// Recive on quit channel// How do we Konw it`s finished?
// Wait for it to tell us it`s done: recive onthe quit channelpackage mainimport ("fmt""math/rand""time"
)func boring(msg string, quit chan string) <-chan string {c := make(chan string)go func() {for i := 0; ; i++ {select {case c <- fmt.Sprintf("%s: %d", msg, i):// do nothingcase <-quit:cleanup()// fmt.Println("boring: Oh! You Stop Me!")quit <- "See you!"return}time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)}}()return c
}func cleanup() {fmt.Println("clean somthings")
}func main() {quit := make(chan string)c := boring("Joe", quit)for i := rand.Intn(10); i >= 0; i-- {fmt.Println(<-c)}quit <- "Bye!"fmt.Printf("Joe says: %q\n", <-quit)
}

demo14

// demo14
// Daisy-chainpackage mainimport "fmt"func f(left, right chan int) {left <- 1 + <-right
}func main() {const n = 100000leftmost := make(chan int)right := leftmost left := leftmostfor i := 0; i < n; i++ {right = make(chan int)go f(left,right)left = right}go func (c chan int)  {c <- 2}(right)fmt.Println(<-leftmost)
}

google-search-00

// demo - Google Search 00
// Google Search: A fake framework
package mainimport ("fmt""math/rand""time"
)var (web   = fakeSearch("web")image = fakeSearch("image")video = fakeSearch("video")
)// Result type
type Result string// Search fake
type Search func(query string) Resultfunc fakeSearch(kind string) Search {return func(query string) Result {time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)return Result(fmt.Sprintf("%s result for %q\n", kind, query))}
}// Google ,
func Google(query string) Result {return Result(fmt.Sprintf("%s%s%s", web(query), image(query), video(query)))
}func main() {rand.Seed(time.Now().UnixNano())start := time.Now()result := Google("google")elapsed := time.Since(start)fmt.Println(result, elapsed)}

google-search-01

// demo - Google Search 01
// Google Search 1.0
// Synchronous
// The Google function takes a query and returns a slice of Results(which are just strings)
// Google invokes Web, Image and Video searches serially, appending them to the results slice.
package mainimport ("fmt""math/rand""time"
)var (web   = fakeSearch("web")image = fakeSearch("image")video = fakeSearch("video")
)// Result type
type Result string// Search fake
type Search func(query string) Resultfunc fakeSearch(kind string) Search {return func(query string) Result {time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)return Result(fmt.Sprintf("%s result for %q\n", kind, query))}
}// Google ,
func Google(query string) (results []Result) {results = append(results, web(query))results = append(results, image(query))results = append(results, video(query))return results
}func main() {rand.Seed(time.Now().UnixNano())start := time.Now()result := Google("google")elapsed := time.Since(start)fmt.Println(result)fmt.Println(elapsed)}

google-search-02

// demo - Google Search 02
// Google Search 2.0
// Run the Web, Image and Video searches concurrently, and wait for all results.
// No locks, No condition variables, No callbacks
package mainimport ("fmt""math/rand""time"
)var (web   = fakeSearch("web")image = fakeSearch("image")video = fakeSearch("video")
)// Result type
type Result string// Search fake
type Search func(query string) Resultfunc fakeSearch(kind string) Search {return func(query string) Result {time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)return Result(fmt.Sprintf("%s result for %q\n", kind, query))}
}// Google ,
func Google(query string) (results []Result) {c := make(chan Result)go func() {c <- web(query)}()go func() {c <- image(query)}()go func() {c <- video(query)}()for i := 0; i < 3; i++ {result := <-cresults = append(results, result)}return results
}func main() {rand.Seed(time.Now().UnixNano())start := time.Now()result := Google("google")elapsed := time.Since(start)fmt.Println(result)fmt.Println(elapsed)}

google-search-03

// demo - Google Search 03
// Google Search 2.1
// Don`t wait for slow servers.
// No locks, No condition variables, No callbacks
package mainimport ("fmt""math/rand""time"
)var (web   = fakeSearch("web")image = fakeSearch("image")video = fakeSearch("video")
)// Result type
type Result string// Search fake
type Search func(query string) Resultfunc fakeSearch(kind string) Search {return func(query string) Result {time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)return Result(fmt.Sprintf("%s result for %q\n", kind, query))}
}// Google ,
func Google(query string) (results []Result) {c := make(chan Result)go func() {c <- web(query)}()go func() {c <- image(query)}()go func() {c <- video(query)}()timeout := time.After(80 * time.Millisecond)for i := 0; i < 3; i++ {select{case result := <-cresults = append(results, result)case <-timeoutfmt.Println("time out")return }}return results
}func main() {rand.Seed(time.Now().UnixNano())start := time.Now()result := Google("google")elapsed := time.Since(start)fmt.Println(result)fmt.Println(elapsed)}

google-search-04

// demo - Google Search 04
// Google Search 3.0// Q: How do we avoid discarding results from slow servers?
// A: Replicate the servers. Send requests to multiple replicas, and use the first response.// Reduce tail latency using replicated search servers.(使用复制的搜索服务器减少尾部延迟。)
package mainimport ("fmt""math/rand""time"
)var (web1   = fakeSearch("web")web2   = fakeSearch("web")image1 = fakeSearch("image")image2 = fakeSearch("image")video1 = fakeSearch("video")video2 = fakeSearch("video")
)// Result 定义返回值
type Result string// Search 搜索服务
type Search func(query string) Result// fakeSearch 虚拟的搜索服务
func fakeSearch(kind string) Search {return func(query string) Result {time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)return Result(fmt.Sprintf("%s result for %q\n", kind, query))}
}// First  query: 查询字串  replicas: 服务器的复制
func First(query string, replicas ...Search) Result {c := make(chan Result)searchReplica := func(i int) {c <- replicas[i](query)}for i := range replicas {go searchReplica(i)}return <-c
}// Google 聚合的Google搜索服务
func Google(query string) (results []Result) {c := make(chan Result)go func() {c <- First(query, web1, web2)}()go func() {c <- First(query, image1, image2)}()go func() {c <- First(query, video1, video2)}()timeout := time.After(80 * time.Millisecond)for i := 0; i < 3; i++ {select {case result := <-c:results = append(results, result)case <-timeout:fmt.Println("time out")return}}return results
}func main() {rand.Seed(time.Now().UnixNano())start := time.Now()result := Google("google")elapsed := time.Since(start)fmt.Println(result)fmt.Println(elapsed)
}

Panda张向北© 2018-2020 版权所有， 采用知识共享署名-非商业性使用-禁止演绎 4.0 国际许可协议许可，代码使用 MIT 协议开源。