精选留言

• 
  坚白同异

  2020-11-09 15:35:09

  思考题
  1.
  func main() {
  ch1 := make(chan int)
  ch2 := make(chan int)
  ch3 := make(chan int)
  ch4 := make(chan int)
  go func() {
  for {
  fmt.Println("I'm goroutine 1")
  time.Sleep(1 * time.Second)
  ch2 <-1 //I'm done, you turn
  <-ch1
  }
  }()
  
  go func() {
  for {
  <-ch2
  fmt.Println("I'm goroutine 2")
  time.Sleep(1 * time.Second)
  ch3 <-1
  }
  
  }()
  
  go func() {
  for {
  <-ch3
  fmt.Println("I'm goroutine 3")
  time.Sleep(1 * time.Second)
  ch4 <-1
  }
  
  }()
  
  go func() {
  for {
  <-ch4
  fmt.Println("I'm goroutine 4")
  time.Sleep(1 * time.Second)
  ch1 <-1
  }
  
  }()
  
  
  
  select {}
  }
  2.双向通道可以赋值给单向,反过来不可以.
• 
  Junes

  2020-11-12 22:28:15

  第一个问题实现的方法有很多，最常规的是用4个channel，我这边分享一个用单channel实现的思路：
  因为channel的等待队列是先入先出的，所以我这边取巧地在goroutine前加一个等待时间，保证1~4的goroutine，他们在同个chan阻塞时是有序的
  
  func main() {
  ch := make(chan struct{})
  for i := 1; i <= 4; i++ {
  go func(index int) {
  time.Sleep(time.Duration(index*10) * time.Millisecond)
  for {
  <-ch
  fmt.Printf("I am No %d Goroutine\n", index)
  time.Sleep(time.Second)
  ch <- struct{}{}
  }
  }(i)
  }
  ch <- struct{}{}
  time.Sleep(time.Minute)
  }
• 
  Noir

  2021-12-19 18:37:45

  package main
  
  import "fmt"
  import "time"
  
  func main() {
  chArr := [4]chan struct{} {
  make(chan struct{}),
  make(chan struct{}),
  make(chan struct{}),
  make(chan struct{}),
  }
  
  for i := 0; i < 4; i++ {
  go func(i int) {
  for {
  <- chArr[i % 4]
  fmt.Printf("i am %d\n", i)
  
  time.Sleep(1 * time.Second)
  chArr[(i + 1) % 4] <- struct{}{}
  }
  }(i)
  }
  
  chArr[0] <- struct{}{}
  select{}
  }

  作者回复

  对

  2021-12-21 08:21:15

• 
  罗帮奎

  2020-11-15 12:01:38

  之前使用go-micro时候就遇到过，unbufferd chan导致的goroutine泄露的bug，当时情况是并发压力大导致rpc调用超时，超时退出当前函数导致了goroutine泄露，go-micro有一段类似的使用unbuffered chan的代码，后来改成了buffer=1
• 
  fhs

  2020-11-11 21:16:47

  func f(i int, input <-chan int, output chan<- int) {
  for {
  <-input
  fmt.Println(i)
  time.Sleep(time.Second)
  output <- 1
  }
  }
  func TestChannelPlan(t *testing.T) {
  c := [4]chan int{}
  for i := range []int{1, 2, 3, 4} {
  c[i] = make(chan int)
  }
  go f(1, c[3], c[0])
  go f(2, c[0], c[1])
  go f(3, c[1], c[2])
  go f(4, c[2], c[3])
  c[3] <- 1
  select {}
  }
  
• 
  星星之火

  2020-12-05 15:12:25

  channel 中包含的 mutex 是什么呢，和课程最开始的 sync.mutex 是同一个东西吗？
  因为 sync.mutex 是依赖 channel 实现的，感觉应该不是同一个 mutex？

  作者回复

  不是同一个，只是类似。channel中这个是运行时内部使用的mutex

  2020-12-05 17:21:45

• 
  Stony.修行僧

  2020-11-11 05:00:45

  一个 goroutine 可以把数据的“所有权”交给另外一个 goroutine（虽然 Go 中没有“所有权”的概念，但是从逻辑上说，你可以把它理解为是所有权的转移）
  这是要推广 Rust啊
• Geek_43dc82

  2022-04-19 18:20:59

  我实在是太蠢了，只能写出这样的代码了
  package main
  
  import "fmt"
  
  func main() {
  signChan1 := make(chan struct{})
  signChan2 := make(chan struct{})
  signChan3 := make(chan struct{})
  signChan4 := make(chan struct{})
  mainSignChan := make(chan struct{})
  
  for i := 1; i <= 4; i++ {
  go func(i int) {
  for {
  select {
  case <-signChan1:
  fmt.Println(1)
  signChan2 <- struct{}{}
  case <-signChan2:
  fmt.Println(2)
  signChan3 <- struct{}{}
  case <-signChan3:
  fmt.Println(3)
  signChan4 <- struct{}{}
  case <-signChan4:
  fmt.Println(4)
  signChan1 <- struct{}{}
  }
  }
  }(i)
  }
  signChan1 <- struct{}{}
  <-mainSignChan
  }
  

  作者回复

  写的不错，简单直接

  2022-04-20 23:50:01

• 
  陌

  2021-04-27 15:14:46

  Goroutine 泄漏的那个例子，如果把 unbuffered chan 改成容量为 1 的 buffered chan，那么假如函数超时了，子 goroutine 也能够往 channel 中发送数据。那么 GC 会把这个 channel 回收吗?

  作者回复

  会

  2021-04-28 23:18:18

• 
  蜗牛🐌

  2021-01-29 16:53:49

  channl1 := make(chan int, 0)
  go func() {
  c := time.NewTicker(1 * time.Second)
  i := 0
  for {
  select {
  case <-c.C:
  i++
  channl1 <- i
  if i == 4 {
  i = 0
  }
  }
  }
  }()
  for {
  select {
  case i := <-channl1:
  fmt.Println(i)
  }
  }
• 
  ldeng 7

  2020-12-02 15:49:06

  对于 select 相关实现的源码个人认为还应该讲一下
• 
  jx

  2025-06-03 17:08:42

  func main() {
  ch := make(chan int, 1)
  ch <- 1
  
  for i := 1; i <= 4; i++ {
  go func(id int) {
  for {
  num := <-ch
  if num != id {
  ch <- num
  continue
  }
  fmt.Println(id)
  time.Sleep(time.Second)
  nextID := id%4 + 1
  ch <- nextID
  }
  }(i)
  }
  
  select {}
  }

  作者回复

  👋

  2025-06-15 19:20:47

• taro

  2022-12-16 19:23:29

  func main() {
  var chans [N]chan struct{}
  for i := 0; i < N; i++ {
  chans[i] = make(chan struct{})
  }
  
  for i := 0; i < N; i++ {
  go func(i int) {
  for {
  <- chans[i]
  fmt.Print(i + 1)
  time.Sleep(time.Second)
  chans[(i + 1) % N] <- struct{}{}
  }
  }(i)
  }
  
  chans[0] <- struct{}{}
  
  select{}
  }
• 
  老猫

  2022-01-23 20:55:57

  func chgoroutine(in,out,stop chan struct{},n int) {
  for{
  select{
  case <-in:
  fmt.Println(n)
  time.Sleep(time.Second)
  out <-struct{}{}
  case <-stop:
  return
  }
  }
  }
  
  func main() {
  ch1 := make(chan struct{}, 0)
  ch2 := make(chan struct{},0)
  ch3 := make(chan struct{},0)
  ch4 := make(chan struct{},0)
  stop := make(chan struct{},0)
  
  go chgoroutine(ch1,ch2,stop,1)
  go chgoroutine(ch2,ch3,stop,2)
  go chgoroutine(ch3,ch4,stop,3)
  go chgoroutine(ch4,ch1,stop,4)
  
  ch1 <-struct{}{}
  
  time.Sleep(time.Second * 20)
  
  stop <-struct{}{}
  }

  作者回复

  😃

  2022-01-24 21:16:43

• 
  50%

  2021-05-25 17:32:55

  func main() {
  const n int = 4
  const maxNum int = 100
  ch := make([]chan struct{}, n)
  for i := range ch {
  ch[i] = make(chan struct{})
  }
  wg := sync.WaitGroup{}
  wg.Add(n)
  i := 0
  go func() {
  ch[0] <- struct{}{}//一个开始的信号
  }()
  for j := 0; j < n; j++ {
  chanNum := (j + 1) % n
  go func() {
  defer wg.Done()
  for {
  <-ch[chanNum]
  fmt.Printf("i am goroutine %d\n", chanNum+1)
  fmt.Println(i) //顺带练习n个goroutine交替打印 0 ~ n
  if i >= math.MaxInt64-1 {
  return
  }
  i++
  time.Sleep(time.Second) //控制打印速率
  ch[(chanNum+1)%n] <- struct{}{}
  
  }
  }()
  }
  wg.Wait()
  }
  
• 
  butterfly

  2021-02-23 18:43:40

  一直有一个疑问： channel底层也是通过一个mutex保护一个环形队列，这种方式和自己通过mutex方式实现的共享资源访问有什么不一样， 好处是什么，性能有多大差异？
• 
  李文通

  2020-12-21 14:53:21

  
  type NumChan struct {
  jobs []*Job
  }
  
  func (n *NumChan) JobNum(m int) {
  for i := 1; i <= m; i++ {
  job := &Job{
  ID: i,
  Jobc: make(chan int, 1),
  }
  go job.run()
  n.jobs = append(n.jobs, job)
  }
  n.run()
  }
  func (n *NumChan) run() {
  for {
  n.seq()
  }
  }
  func (n *NumChan) seq() {
  for _, j := range n.jobs {
  j.Jobc <- 1
  time.Sleep(time.Second * 1)
  }
  }
  
  type Job struct {
  ID int
  Jobc chan int
  }
  
  func (j *Job) run() {
  for {
  select {
  case <-j.Jobc:
  fmt.Printf("id %d\n", j.ID)
  }
  }
  }
  
  func main() {
  n := &NumChan{}
  n.JobNum(4)
  }
  
• 
  虫子樱桃

  2020-11-12 14:46:32

  /*
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFINGEMENT. IN NO EVENT SHALL THEq
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
  
  package main
  
  import (
  "fmt"
  "time"
  )
  
  type NumberChan struct {
  Ch chan int
  ChannelNumber int
  }
  
  func (nch *NumberChan) SendNotify() {
  go func() {
  nch.Ch <- nch.ChannelNumber
  }()
  }
  
  func (nch *NumberChan) PrintInfo() {
  fmt.Println(nch.ChannelNumber)
  time.Sleep(time.Second)
  }
  
  func NewNumberChan(seq int) *NumberChan {
  nch := NumberChan{
  Ch: make(chan int),
  ChannelNumber: seq,
  }
  return &nch
  }
  
  func main() {
  var (
  nch1 = NewNumberChan(1)
  nch2 = NewNumberChan(2)
  nch3 = NewNumberChan(3)
  nch4 = NewNumberChan(4)
  )
  go func() {
  nch1.SendNotify()
  }()
  for {
  select {
  case <-nch1.Ch:
  nch1.PrintInfo()
  nch2.SendNotify()
  case <-nch2.Ch:
  nch2.PrintInfo()
  nch3.SendNotify()
  case <-nch3.Ch:
  nch3.PrintInfo()
  nch4.SendNotify()
  case <-nch4.Ch:
  nch4.PrintInfo()
  nch1.SendNotify()
  }
  }
  
  }
  
• 
  那时刻

  2020-11-10 00:41:14

  思考题1.
  
  const chanNum int = 4
  func taskSchedule() {
  chanArr := make([]chan int, chanNum)
  for i := 0; i < chanNum; i++ {
  ch := make(chan int, 1)
  chanArr[i] = ch
  }
  
  chanArr[0] <- 1
  for i := 0; i < chanNum; i++ {
  nextChanIdx := ( i + 1 ) % chanNum
  go func(cur, next chan int, idx int) {
  for {
  <- cur
  time.Sleep(1 * time.Second)
  fmt.Printf("%d\n", idx + 1)
  next <- 1
  }
  }(chanArr[i], chanArr[nextChanIdx], i)
  }
  }
• 
  青鸟飞鱼

  2020-11-09 12:53:33

  一般来说，单向通道有什么用呢？