3个关于协程的题目

题目1：

题目1：启动2个协程，1个管道，每隔1秒交替输出1次1-10和a-j。

预期效果：

实现方式：

package main

import (
	"fmt"
	"sync"
	"time"
)

var ch = make(chan struct{}, 1)
var wg sync.WaitGroup

func main() {
	wg.Add(2)
	go printLetter()
	go printNumber()
	wg.Wait()
}

func printLetter() {
	defer wg.Done()
	for i := 'a'; i <= 'j'; i++ {
		<-ch
		fmt.Println(string(i))
	}
}

func printNumber() {
	defer wg.Done()
	for i := 1; i <= 10; i++ {
		fmt.Println(i)
		ch <- struct{}{}
		time.Sleep(time.Second)
	}
}

 题目2：

题目2：启动2个协程，2个管道，每隔1秒交替输出1次1-10和a-j。

预期效果：

实现方式：

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup

	// 需要等待2个协程完成
	wg.Add(2)

	// 使用channel来控制输出顺序
	numCh := make(chan bool, 1)
	letterCh := make(chan bool, 1)

	// 启动数字输出协程
	go func() {
		// 通知waitGroup 一个协程已经完成
		defer wg.Done()

		for i := 1; i <= 10; i++ {
			<-numCh
			fmt.Printf("%d ", i)
			letterCh <- true
		}
	}()

	// 启动字母输出协程
	go func() {
		// 通知waitGroup 一个协程已经完成
		defer wg.Done()

		for c := 'A'; c <= 'J'; c++ {
			<-letterCh
			fmt.Printf("%c ", c)
			numCh <- true
		}
	}()

	// 启动输出
	numCh <- true

	// 等待两个协程完成
	wg.Wait()
}

  题目3：

题目3：现在有从1-10总共10个数，最多同时只能有3个协程去读，每个协程读1个数并输出，并且sleep1秒，直到读完这10个数为止。

预期效果：

实现方式：

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	// 创建一个用于同步的 WaitGroup
	var wg sync.WaitGroup

	// 创建一个有缓冲的 channel，用于控制同时运行的协程数量
	ch := make(chan struct{}, 3)

	// 创建一个数字的切片
	numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

	for _, num := range numbers {
		wg.Add(1) // 每次启动一个新协程之前，增加 WaitGroup 的计数
		ch <- struct{}{} // 尝试往 channel 中发送一个空结构体，限制同时运行的协程数量

		go func(n int) {
			defer wg.Done() // 完成后减少计数
			defer func() { <-ch }() // 从 channel 中取出，释放位置

			time.Sleep(1 * time.Second) // 模拟处理时间
			fmt.Println(n) // 输出当前数字
		}(num)
	}

	wg.Wait() // 等待所有协程完成
}