关于Go中使用goroutine协程实现的算法

select中case的使用

请问以下程序的输出结果？

func case1() {
	c1 := make(chan int)
	c2 := make(chan int)
	close(c1)
	close(c2)
	select {
	case <-c1:
		fmt.Println("c1")
	case c2 <- 1:
		fmt.Println("c2")
	default:
		fmt.Println("default")
	}
}

非阻塞select

以下程序输出结果？

func case2() {
	c := make(chan int, 1)
	done := false
	for !done {
		select {
		case <-c:
			print(1)
			c = nil
		case c <- 1:
			print(2)
		default:
			print(3)
			done = true
		}
	}
}

有4个goroutine，按编号1、2、3、4循环打印

func case3() {
	ch := make([]chan int, 4)
	for i := range ch {
		ch[i] = make(chan int)
		go func(i int) {
			for {
				v := <-ch[i]
				fmt.Println(v + 1)
				time.Sleep(time.Second)
				ch[(i+1)%4] <- (v + 1) % 4
			}
		}(i)
	}
	ch[0] <- 0
	select {}
}

使用三个协程，每秒钟打印cat dog fish

func case4() {
	chCat := make(chan struct{})
	chDog := make(chan struct{})
	chFish := make(chan struct{})

	go func() {
		for {
			<-chCat
			fmt.Println("cat")
			time.Sleep(time.Second)
			chDog <- struct{}{}
		}

	}()
	go func() {
		for {
			<-chDog
			fmt.Println("dog")
			time.Sleep(time.Second)
			chFish <- struct{}{}
		}

	}()
	go func() {
		for {
			<-chFish
			fmt.Println("fish")
			time.Sleep(time.Second)
			chCat <- struct{}{}
		}

	}()
	chCat <- struct{}{}
	select {}
}

实现两个goroutine轮流输出A 1 B 2 C 3…Z 26

func case5() {
	byteCh := make(chan struct{}, 1)
	intCh := make(chan struct{}, 1)
	byteCh <- struct{}{}
	go func() {
		for {
			for i := 'A' - 0; i <= 'Z'-0; i++ {
				<-byteCh
				fmt.Println(string(i))
				intCh <- struct{}{}
			}
		}

		//return
	}()
	go func() {
		for {
			for i := 1; i <= 26; i++ {
				<-intCh
				fmt.Println(i)
				byteCh <- struct{}{}
			}
		}
		//return
	}()
	time.Sleep(time.Second)
}

用N个goroutine去按顺序打印数字

func case6() {
	const n = 5
	ch := make([]chan int, n)
	for i := 0; i < n; i++ {
		ch[i] = make(chan int, 1)
	}
	for i := 0; i < n; i++ {
		go printNum(i, ch[i])
	}
	count := 0
	for i := 0; i < 100; i++ {
		for j := 0; j < n; j++ {
			ch[j] <- count
			count++
			time.Sleep(time.Second * 1)
		}
	}
}

func printNum(gid int, ch chan int) {
	for {
		fmt.Printf("g:%d，num:%d\n", gid, <-ch)
	}
}

有一个数组，用两个协程，一个打印所有偶数的和，一个打印所有奇数的和，要用for channel机制

func case7() {
	nums := [5]int{1, 2, 32, 41, 5}
	oneCh := make(chan int, 1)
	twoCh := make(chan int, 1)
	go printOld(oneCh, nums[:])
	go printNew(twoCh, nums[:])
	fmt.Println(<-oneCh)
	fmt.Println(<-twoCh)
}

func printOld(ch chan int, arr []int) {
	sum := 0
	for _, v := range arr {
		if v%2 == 0 {
			sum += v
		}
	}
	ch <- sum
}

func printNew(ch chan int, arr []int) {
	sum := 0
	for _, v := range arr {
		if v%2 != 0 {
			sum += v
		}
	}
	ch <- sum
}