go channel详解

协程,通道

  • 我们在普通程序中要执行代码如下代码
func main() {
    foo()
    bar()
}
func foo() {
    for i := 0; i < 45; i++ {
        fmt.Println("Foo:", i)
    }
}
func bar() {
    for i := 0; i < 45; i++ {
        fmt.Println("Bar:", i)
    }
}
得到结果
Foo: 41
Foo: 42
Foo: 43
Foo: 44
Bar: 0
Bar: 1
Bar: 2
Bar: 3
这个是按顺序执行的
  • 错误使用协程
package main
import "fmt"
func main() {
    go foo()
    go bar()
}
func foo() {
    for i := 0; i < 45; i++ {
        fmt.Println("Foo:", i)
    }
}
func bar() {
    for i := 0; i < 45; i++ {
        fmt.Println("Bar:", i)
    }
}

由于没有调度,主协程率先执行完毕,代码执行已经关闭,所以协程根本没有执行。

  • 正确使用协程
package main
import (
    "fmt"
    "sync"
)
var wg sync.WaitGroup
func main() {
    wg.Add(2)
    go foo()
    go bar()
    wg.Wait()
}
func foo() {
    for i := 0; i < 45; i++ {
        fmt.Println("Foo:", i)
    }
    wg.Done()
}
func bar() {
    for i := 0; i < 45; i++ {
        fmt.Println("Bar:", i)
    }
    wg.Done()
}

用sync.WaitGroup,可以阻塞主线程,wg.Add(2)加入两个子线程,wg.Wait()一直等待,每当一个执行完成调用函数wg.Done()将一个线程去掉,直到全部执行完子线程。‘’

  • 协程:正如官方所言,goroutine 是一个轻量级的执行单元,相比线程开销更小,完全由 Go 语言负责调度,是 Go 支持并发的核
    心。开启一个 goroutine 非常简单:

  • 协程的运行

package main
   import (
    "fmt"
    "time"
)
func main() {
    go fmt.Println("goroutine message")
    time.Sleep(1) //1
    fmt.Println("main function message")
}
  • 协程的好处,上面的例子我们没有看到协程究竟能有什么好处
package main
import (
    "fmt"
    "sync"
    "time"
)
var wg sync.WaitGroup

func main() {
    wg.Add(3)
    go foo()
    go bar()
    go dar()
    wg.Wait()
}
func foo() {
    for i := 0; i < 45; i++ {
        fmt.Println("Foo:", i)
        time.Sleep(3 * time.Millisecond)
    }
    wg.Done()
}
func bar() {
    for i := 0; i < 45; i++ {
        fmt.Println("Bar:", i)
        time.Sleep(20 * time.Millisecond)
    }
    wg.Done()
}
func dar() {
    for i := 0; i < 45; i++ {
        fmt.Println("dar:", i)
    }
    wg.Done()
}

从上面的代码执行效果看到,协程能够使我们,遇到阻塞,不会阻塞到那,另一个协程还会继续执行。

  • 在前面我们只是用了系统中的单核,go其实是一门异步多线程语言
package main
import (
    "fmt"
    "runtime"
    "sync"
    "time"
)
var wg sync.WaitGroup

func init() {
    runtime.GOMAXPROCS(runtime.NumCPU())
}
func main() {
    wg.Add(2)
    go foo()
    go bar()
    wg.Wait()
}
func foo() {
    for i := 0; i < 45; i++ {
        fmt.Println("Foo:", i)
        time.Sleep(3 * time.Millisecond)
    }
    wg.Done()
}
func bar() {
    for i := 0; i < 45; i++ {
        fmt.Println("Bar:", i)
        time.Sleep(20 * time.Millisecond)
    }
    wg.Done()
}

当某个协程阻塞时,cpu会把其他协程加载进来执行,这样确保cpu不会空闲着。 runtime.GOMAXPROCS(runtime.NumCPU())表示在系统的所有核上并发运行。

  • 竞争当用同一个变量时,该变量会使该变量变化。
package main
import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)
var wg sync.WaitGroup
var counter int
func main() {
    wg.Add(2)
    go incrementor("Foo:")
    go incrementor("Bar:")
    wg.Wait()
    fmt.Println("Final Counter:", counter)
}
func incrementor(s string) {
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < 20; i++ {
        x := counter
        x++
        time.Sleep(time.Duration(rand.Intn(3)) * time.Millisecond)
        counter = x
        fmt.Println(s, i, "Counter:", counter)
    }
    wg.Done()
}
  • 加锁
package main
import (
   "fmt"
   "math/rand"
   "sync"
   "time"
)
var wg sync.WaitGroup
var counter int
var mutex sync.Mutex
func main() {
   wg.Add(2)
   go incrementor("Foo:")
   go incrementor("Bar:")
   wg.Wait()
   fmt.Println("Final Counter:", counter)
}
func incrementor(s string) {
   for i := 0; i < 20; i++ {
       time.Sleep(time.Duration(rand.Intn(20)) * time.Millisecond)
       mutex.Lock()
       counter++
       fmt.Println(s, i, "Counter:", counter)
       mutex.Unlock()
   }
   wg.Done()
}

  • 原子操作
package main

import (
   "fmt"
   "math/rand"
   "sync"
   "sync/atomic"
   "time"
)
var wg sync.WaitGroup
var counter int64
func main() {
   wg.Add(2)
   go incrementor("Foo:")
   go incrementor("Bar:")
   wg.Wait()
   fmt.Println("Final Counter:", counter)
}
func incrementor(s string) {
   for i := 0; i < 20; i++ {
       time.Sleep(time.Duration(rand.Intn(3)) * time.Millisecond)
       atomic.AddInt64(&counter, 1)
       fmt.Println(s, i, "Counter:", atomic.LoadInt64(&counter)) // access without race
   }
   wg.Done()
}

// go run -race main.go
// vs
// go run main.go

  • 为什么要需要channel
    time.Sleep(1) 这是为了让新开启的 goroutine 有机会得到执行,开启一个 goroutine 之后,后续的代码会继续执行,在上面的例子中后续代码执行完毕程序就终止了,而开启的 goroutine 可能还没开始执行。
    如果尝试去掉 #1 处的代码,程序也可能会正常运行,这是因为恰巧开启的 goroutine 只是简单的执行了一次输出,如果 goroutine 中耗时稍长就会导致只能看到主一句 main function message 。
    换句话话说,这里的 time.sleep 提供的是一种调度机制,这也是 Go 中 channel 存在的目的:负责消息传递和调度。

  • 什么是channel
    Channel 是 Go 中为 goroutine 提供的一种通信机制,channel 是有类型的,而且是有方向的,可以把 channel 类比成 unix
    中的 pipe。channel 是用来传递消息的。

package main
import (
   "fmt"
 )
func main() {
 i := make(chan int)//int 类型
 s := make(chan string)//字符串类型
 r := make(<-chan bool)//只读
 w := make(chan<- []int)//只写
   c := make(chan int)
   go func() {
       fmt.Println("goroutine message")
       c <- 1 //1
   }()
   <-c //2
   fmt.Println("main function message")
}

声明了一个 int 类型的 channel,在 goroutine 中在代码 #1 处向 channel 发送了数据 1 ,在 main 中 #2 处等待数据的接收,如果 c 中没有数据,代码的执行将发生阻塞,直到 c 中数据接收完毕。这是 channel 最简单的用法之一:同步 ,这种类型的 channel 没有设置容量,称之为 unbuffered channel。
发送与等待互相阻塞,

推荐阅读更多精彩内容

  • Goroutine是Go里的一种轻量级线程——协程。相对线程,协程的优势就在于它非常轻量级,进行上下文切换的代价非...
    witchiman阅读 3,344评论 0 9
  • 原文链接:https://github.com/EasyKotlin 在常用的并发模型中,多进程、多线程、分布式是...
    JackChen1024阅读 8,423评论 3 23
  • 本文主要介绍协程的用法, 以及使用协程能带来什么好处. 另外, 也会粗略提一下协程的大致原理.本文的意义可能仅仅是...
    登高而望远阅读 23,334评论 17 115
  • GO并发使用goroutine运行程序,检测并修正状态,利用通道共享数据。通常程序会被编写为一个顺序执行并完成一个...
    小线亮亮阅读 223评论 0 1
  • 多进程/线程 最早的服务器端程序都是通过多进程、多线程来解决并发IO的问题。进程模型出现的最早,从Unix 系统诞...
    Newt0n阅读 12,020评论 9 69