Go之组件学习-channel(concurrency篇)

664 阅读1分钟

本文已参与「新人创作礼」活动,一起开启掘金创作之路。

Go之组件学习-channel(concurrency篇)

导语:

最近在学习关于go语言的concurrency的channel模块,就看到了ardan labs里面的一些例子,促进理解channel一些原理和使用

一、channel的定义

Channels allow goroutines to communicate with each other through the use of signaling semantics. Channels accomplish this signaling through the use of sending/receiving data or by identifying state changes on individual channels. Don't architect software with the idea of channels being a queue, focus on signaling and the semantics that simplify the orchestration required.

通道允许goroutine通过使用信令语义相互通信。信道通过使用发送/接收数据或识别单个信道上的状态变化来完成该信令。不要以通道是队列的想法来构建软件,而应关注简化所需编排的信令和语义。

二、channel的使用方式

在go中定义一个chan,即可开启通道模式

例如

  ch := make(chan int, 1)
  ch <- 1
  fmt.Println(<-ch)

以上的 ch<-1 就是将数据发送到channel中,而*<-ch*就是将数据发送出去。

这样可以实现channel管道接收和发送数据。

三、channel的一些场景

buffered(阻塞)

image.png

阻塞场景,并发场景,多数据的发送和多用户接收需要从channel中慢慢存和取,时间上延时性高,但是实现了高性能高效率传输。

unbuffered(非阻塞)

image.png

非阻塞场景也是比较常见的,它实现了数据的快速发送和接收,常用于对等单个gorountine使用,一对一聊天室?低延时,但需要多个gorountine的建立,消耗大量性能。

四、channel的一些简单场景应用

1)父goroutine通过channel管道等待子goroutine的数据发送

// waitForResult: In this pattern, the parent goroutine waits for the child
// goroutine to finish some work to signal the result.
// 父goroutine等待信号结果
func waitForResult() {
  ch := make(chan string)
​
  go func() {
    time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
    ch <- "data"
    fmt.Println("child : sent signal")
  }()
​
  d := <-ch
  fmt.Println("parent : recv'd signal :", d)
​
  time.Sleep(time.Second)
  fmt.Println("-------------------------------------------------")
}

2)父goroutine发出100份信号,子goroutine一个pool池将等待信号接收

// pooling: In this pattern, the parent goroutine signals 100 pieces of work
// to a pool of child goroutines waiting for work to perform.
//父goroutine发出100份信号,子goroutine池将等待并工作
func pooling() {
  ch := make(chan string)
  //设置可以执行的最大CPU数量,指的是线程
  g := runtime.GOMAXPROCS(0)
  fmt.Println("====",g)
  for c := 0; c < g; c++ {
    go func(child int) {
      fmt.Println("!!!!!1")
      for d := range ch {
        fmt.Printf("child %d : recv'd signal : %s\n", child, d)
      }
      fmt.Printf("child %d : recv'd shutdown signal\n", child)
    }(c)
  }
​
  const work = 100
  for w := 0; w < work; w++ {
    ch <- "data" + strconv.Itoa(w)
    fmt.Println("parent : sent signal :", w)
  }
​
  close(ch)
  fmt.Println("parent : sent shutdown signal")
​
  time.Sleep(time.Second)
  fmt.Println("-------------------------------------------------")
}

3)使用channel管道模拟两个人网球比赛

// Sample program to show how to use an unbuffered channel to
// simulate a game of tennis between two goroutines.
//两个goroutines之间模拟网球比赛。
package main
​
import (
  "fmt"
  "math/rand"
  "sync"
  "time"
)
​
func init() {
  rand.Seed(time.Now().UnixNano())
}
​
func main() {
​
  // Create an unbuffered channel.
  court := make(chan int)
​
  // wg is used to manage concurrency.
  var wg sync.WaitGroup
  wg.Add(2)
​
  // Launch two players.
  go func() {
    player("Serena", court)
    wg.Done()
  }()
​
  go func() {
    player("Venus", court)
    wg.Done()
  }()
​
  // Start the set.
  court <- 1// Wait for the game to finish.
  wg.Wait()
}
​
// player simulates a person playing the game of tennis.
func player(name string, court chan int) {
  for {
​
    // Wait for the ball to be hit back to us.
    ball, wd := <-court
    if !wd {
​
      // If the channel was closed we won.
      fmt.Printf("Player %s Won\n", name)
      return
    }
​
    // Pick a random number and see if we miss the ball.
    n := rand.Intn(100)
    if n%13 == 0 {
      fmt.Printf("Player %s Missed\n", name)
​
      // Close the channel to signal we lost.
      close(court)
      return
    }
​
    // Display and then increment the hit count by one.
    fmt.Printf("Player %s Hit %d\n", name, ball)
    ball++
​
    // Hit the ball back to the opposing player.
    court <- ball
  }
}
​
​

五、channel 一些禁止项

image.png

在数据发送和接收这两种方式里,在channel管道关闭后,也有一些禁止项

比如说

管道closed后,不允许在发送数据,如果在发送数据会产生panic报错。

  ch := make(chan int,2)
  ch <- 1 //发送1到管道ch
  fmt.Println(<-ch)//接收管道的数据1
  close(ch)//关闭管道
  ch <- 2 //发送管道报错,已经关闭管道顾不可再发送,panic
  fmt.Println(<-ch)

以上代码将会报panic: send on closed channel错误

经过测试,改成以下代码印证了这个禁止项

  ch := make(chan int,2)
  ch <- 1//发送1到管道ch
  ch <- 2//发送2到管道ch
  fmt.Println(<-ch)//接收管道的数据1
  close(ch)
  fmt.Println(<-ch)//接收管道的数据2

文章借鉴

\