go当中的channel 无缓冲channel和缓冲channel的适用场景、结合select的使用

本文介绍: Go channel就像Go并发模型中的“胶水”，它将诸多并发执行单元连接起来，或者正是因为有channel的存在，Go并发模型才能迸发出强大的表达能力。

可以通过不带有capacity参数的内置make 函数创建一个可用的无缓冲 channel：

c := make(chan T)

由于无缓冲 channel的运行时层实现不带有缓冲区，因此对无缓冲channel的接收和发送操作是同步的。

一个无缓冲的channel动作发生和完成的时序如下：

这与Go官方“Go内存模型”一文中对channel通信的描述是一致的。正因如此，下面的代码可以保证main 输出的变量a的值为”hello, world“：

var c = make(chan int)
var a string

func f() {
    a = "hello, world"
    <-c
}

func main() {
    go f()
    c <- 5
    println(a)
}

因为函数f中的channel接收动作发生在主goroutine对channel发送动作完成之前，而a = “hello, world“语句又发生在channel接收动作之前，因此主goroutine在channel发送操作完成后看到的变量a的值一定是”hello, world”，而不是空字符串。

// 通知其他goroutine工作线程已完成
type signal struct{}

func worker(i int) {
	fmt.Printf("worker %v is workingn", i)
	time.Sleep(5 * time.Second)
	fmt.Printf("worker %v : works donen", i)
}

// spawnGroup 是一个用于生成一组工作线程的函数
// 参数:
//   - f: 工作函数，每个工作线程都会执行该函数
//   - num: 工作线程的数量
//   - groupSignal: 用于控制工作线程启动和停止的信号通道
//
// 返回值:
//   - <-chan signal: 用于接收所有工作线程完成的信号通道
func spawnGroup(f func(i int), num int, groupSignal <-chan signal) <-chan signal {
	c := make(chan signal)
	var wg sync.WaitGroup
	for i := 0; i < num; i++ {
		wg.Add(1)
		go func(i int) {
			<-groupSignal //阻塞，等待启动信号
			fmt.Printf("worker %v: start to workn", i)
			f(i)
			wg.Done() //工作完成，减少WaitGroup的计数
		}(i + 1)
	}

	go func() {
		wg.Wait()
		c <- signal(struct{}{}) //发送信号通知
	}()
	return c
}

func main() {
	fmt.Println("start a group of workers...")
	groupSignal := make(chan signal)
	c := spawnGroup(worker, 5, groupSignal)
	time.Sleep(10 * time.Second)
	fmt.Println("the group of workers start to work...")
	// 关闭工作组信号通道，通知所有工作线程开始工作
	close(groupSignal)
	<-c
	fmt.Println("the group of workers work done!")
}

type counter struct {
	c chan int
	i int
}

var cter counter

func InitCounter() {
	cter = counter{
		c: make(chan int),
	}
	// 增加计数器的动作相当于一次接收动作
	go func() {
		for {
			cter.i++
			cter.c <- cter.i
		}
	}()
	fmt.Println("counter init ok")
}

func Increase() int {
	return <-cter.c
}

func init() {
	InitCounter()
}

func main() {
	for i := 0; i < 10; i++ {
		go func(i int) {
			v := Increase()
			fmt.Printf("goroutine-%d: current counter value is %dn", i, v)
		}(i)
	}
	time.Sleep(5 * time.Second)
}

c := make(chan T, capacity)

// 同一时间最多3个活跃状态
var active = make(chan struct{}, 3)
var jobs = make(chan int, 10)

func main() {
	go func() {
		for i := 0; i < 8; i++ {
			jobs <- i + 1
		}
		close(jobs)
	}()
	var wg sync.WaitGroup
	for j := range jobs {
		wg.Add(1)
		go func(j int) {
			active <- struct{}{}
			log.Printf("handle job: %vn", j)
			time.Sleep(2 * time.Second)
			<-active
			wg.Done()
		}(j)
	}
	wg.Wait()
}

func producer(c chan<- int) {
	var i int = 1
	for {
		time.Sleep(2 * time.Second)
		ok := trySend(c, i)
		if ok {
			fmt.Printf("[producer]: send [%d] to channeln", i)
			i++
			continue
		}
		fmt.Printf("[producer]: try send [%d], but channel is fulln", i)
	}
}

func tryRecv(c <-chan int) (int, bool) {
	select {
	case i := <-c:
		return i, true
	default:
		return 0, false
	}
}

func trySend(c chan<- int, i int) bool {
	select {
	case c <- i:
		return true
	default:
		return false
	}
}

func consumer(c <-chan int) {
	for {
		i, ok := tryRecv(c)
		if !ok {
			fmt.Println("[consumer]: try to recv from channel, but the channel is empty")
			time.Sleep(1 * time.Second)
			continue
		}
		fmt.Printf("[consumer]: recv [%d] from channeln", i)
		if i >= 3 {
			fmt.Println("[consumer]: exit")
			return
		}
	}
}

func main() {
	c := make(chan int, 3)
	go producer(c)
	go consumer(c)

	select {} // 仅用于演示，临时用来阻塞主goroutine
}

func main() {
	var c chan int
	<-c
}

func main() {
    c1, c2 := make(chan int), make(chan int)
    go func() {
        time.Sleep(time.Second * 5)
        c1 <- 5
        close(c1)
    }()
    
    go func() {
        time.Sleep(time.Second * 7)
        c2 <- 7
        close(c2)
    }()
    
    for {
        select {
        case x, ok := <-c1:
	// 对于一个nil channel执行获取操作，该操作会被堵塞，因此可以显示设置
            if !ok {
                c1 = nil
            } else {
                fmt.Println(x)
            }
        case x, ok := <-c2:
                if !ok {
                    c2 = nil
                } else {
                    fmt.Println(x)
                }
        }
        if c1 == nil &amp;&amp; c2 == nil {
            break
        }
    }
    fmt.Println("program end")
}

func sendTime(c interface{}, seq uintptr) {
    // 无阻塞地向c发送当前时间
    // ...
    select {
        case c.(chan Time) <- Now():
        default:
    }
}

func worker() {
	select {
	case <-c:
		//...
	case <-time.After(30*time.Second):
		return
	}
}

func worker() {
    heartbeat := time.NewTicker(30 * time.Second)
    defer heartbeat.Stop()
    for {
        select {
        case <-c:
            // ... 处理业务逻辑
        case <- heartbeat.C: //记得调用方法停止运作
            //... 处理心跳
        }
    }
}