启动两个线程, 一个输出 1,3,5,7…99, 另一个输出 2,4,6,8…100 最后 STDOUT 中按序输出 1,2,3,4,5…100？

时间：2019.10.30
背景：在一个摸鱼群里看到一道面试题，这里用golang实现练习巩固相关知识。
问题：启动两个线程, 一个输出 1,3,5,7…99, 另一个输出 2,4,6,8…100 最后 STDOUT 中按序输出 1,2,3,4,5…100？
语言：Golang

1.用 sync.Cond 实现

sync.Cond 实现了一个条件变量，在 Locker 的基础上增加了一个消息通知的功能，其内部维护了一个等待队列，队列中存放的是所有等待在这个 sync.Cond 的 Go 程，即保存了一个通知列表。sync.Cond 可以用来唤醒一个或所有因等待条件变量而阻塞的 Go 程，以此来实现多个 Go 程间的同步。sync.Cond 的定义及成员函数如下：

type Cond struct {
    // L is held while observing or changing the condition
	L Locker
	// contains filtered or unexported fields
}

//创建一个带锁的条件变量，Locker 通常是一个 *Mutex 或 *RWMutex
func NewCond(l Locker) *Cond

//唤醒所有因等待条件变量 c 阻塞的 goroutine
func (c *Cond) Broadcast()

//唤醒一个因等待条件变量 c 阻塞的 goroutine
func (c *Cond) Signal()

//自动解锁 c.L 并挂起 goroutine。只有当被 Broadcast 和 Signal 唤醒，Wait 才能返回，返回前会锁定 c.L
func (c *Cond) Wait()

代码实现

package dtest

import (
	"fmt"
	"sync"
	"testing"
)

var (
	wg    = sync.WaitGroup{}
	mu    = &sync.Mutex{}
	cond1 = sync.NewCond(mu)
	cond2 = sync.NewCond(mu)
)

func TestT(t *testing.T) {
	wg.Add(2)
	go thread1()
	go thread2()
	wg.Wait()
	fmt.Println("end")
}

func thread1() {
	for i := 1; i <= 100; i += 2 {
		mu.Lock() //获取锁
		if i != 1 {
			cond1.Wait() //等待通知 挂起线程
		}
		fmt.Println("thread1 ->", i)
		mu.Unlock()
		cond2.Broadcast() //通知
	}
	wg.Done()
}

func thread2() {
	for i := 2; i <= 100; i += 2 {
		mu.Lock()
		cond2.Wait()
		fmt.Println("thread2 ->", i)
		mu.Unlock()
		cond1.Broadcast()
	}
	wg.Done()
}

2.用 Channel 实现

Go Channel 的发送与接收默认是阻塞的。当把数据发送到信道时，程序控制会在发送数据的语句处发生阻塞，直到有其它 Go 协程从信道读取到数据，才会解除阻塞。与此类似，当读取信道的数据时，如果没有其它的协程把数据写入到这个信道，那么读取过程就会一直阻塞着。

package dtest

import (
	"fmt"
	"sync"
	"testing"
)

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

func TestT(t *testing.T) {
	wg.Add(2)
	go thread1()
	go thread2()
	wg.Wait()
	fmt.Println("end")

}

func thread1() {
	for i := 1; i <= 100; i += 2 {
		if i != 1 {
			<-signal1 //读取数据，没有数据时堵塞
		}
		fmt.Println("thread1 ->", i)
		signal2 <- struct{}{} //发送数据
	}
	wg.Done()
}

func thread2() {
	for i := 2; i <= 100; i += 2 {
		<-signal2
		fmt.Println("thread2 ->", i)
		signal1 <- struct{}{}
	}
	wg.Done()
}

输出：

thread1 -> 1
thread2 -> 2
thread1 -> 3
thread2 -> 4
thread1 -> 5
thread2 -> 6
thread1 -> 7
thread2 -> 8
thread1 -> 9
thread2 -> 10
......
thread1 -> 93
thread2 -> 94
thread1 -> 95
thread2 -> 96
thread1 -> 97
thread2 -> 98
thread1 -> 99
thread2 -> 100