Golang有意义的问题-并发下的有序输出

@Golang有意义的问题

和尚搬家

从前，有三个和尚，需要搬家，唯一的要求是要保证搬家前后房内物品布局一致，然后我编不下去了…

问

如何使用3个goroutine是由1-100的有序输出？

分析

问题的核心在于如何保证在并发条件下的有序输出。

主动控制式

package main

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

func main() {
	q := make(chan int)
	wg := new(sync.WaitGroup)
	wg.Add(1)
	go func(wg *sync.WaitGroup, q chan<- int) {
		defer wg.Done()
		defer close(q)
		for i := 1; i <= 100; i++ {
			q <- i
			time.Sleep(time.Microsecond)  // 利用休眠实现对生产者的控制，但这种方案不可靠
		}

	}(wg, q)
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go func(wg *sync.WaitGroup, q <-chan int) {
			defer wg.Done()
			for {
				if v, ok := <-q; ok {
					fmt.Println(v)
				} else {
					return
				}
			}
		}(wg, q)
	}
	wg.Wait()
}
// 利用WaitGroup实现安全退出，使生产者休眠来进行控制，但是如果消费者的操作是耗时是不可靠谱的，就会变得不可靠

package main

import (
	"fmt"
	"time"
)

func print(ch <-chan int){
	for{
		fmt.Println(<-ch)
	}
	
}

func main() {
	ch0 :=make(chan int)
	ch1 :=make(chan int)
	ch2 :=make(chan int)
	go print(ch0)
	go print(ch1)
	go print(ch2)
	for i:=1; i<101; i++{
		switch{
		case i%3 == 0:
			ch0 <- i
		case i%3 == 1:
			ch1 <- i
		case i%3 == 2:
			ch2 <-i
		}
		time.Sleep(time.Microsecond)
	}
}
//  利用for循环实现安全退出，同样是使生产者休眠来进行控制，但是如果消费者的操作是耗时是不可靠谱的，就会变得不可靠

package main

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

func main() {
	q := make(chan int,100)
	// 填充管道
	for i := 1; i <= 100; i++ {
		q<-i
	}
	cond := sync.NewCond(&sync.Mutex{})
	for i := 0; i < 3; i++ {
		go func(c *sync.Cond, q <-chan int) {
			for {
				c.L.Lock()
				c.Wait()
				if v, ok := <-q; ok {
					fmt.Println(v)
					c.L.Unlock()
				} else {
					c.L.Unlock()
					return
				}
			}
		}(cond, q)
	}
	time.Sleep(time.Second) // 使所有的goroutine进入等待状态
	for i := 1; i <= 100; i++ {
		cond.Signal() // 唤醒一个等待状态的goroutine
		time.Sleep(time.Microsecond)
	}
	close(q)
	time.Sleep(time.Second)
}
// 利用cond是所有goroutine进入阻塞状态直到被唤醒来实现有序输出，cond和其他锁不一样，临界资源被锁之后goroutine不会进行轮询，而是等待调度，减少资源开销

抢占式

package main

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

func main() {
	q := make(chan int)
	wg := new(sync.Mutex)
	go func( q chan<- int) {
		defer close(q)
		for i := 1; i <= 100; i++ {
			q <- i
		}

	}(q)
	for i := 0; i < 3; i++ {
		go func(wg *sync.Mutex, q <-chan int) {
			for {
				wg.Lock()
				if v, ok := <-q; ok {
					fmt.Println(v)
					wg.Unlock()
				} else {
					wg.Unlock()
					return
				}
			}
		}(wg, q)
	}
	time.Sleep(time.Second)  // 安全退出
}
// 使用互斥锁阻塞其他协程来实现抢占，使用休眠实现安全退出，这种方案是可靠的，但最好能够使用WaitGroup来实现安全退出

package main

import (
	"fmt"
	"time"
)

func main() {
	a := 0
	fn := func() int {
		a++
		return a
	}

	ch := make(chan int, 1)
	defer close(ch)

	for i := 0; i < 3; i++ {
		go func() {
			for {
				ch <- 1
				n := fn()
				if n > 100 {
					break
				}
				fmt.Println(n)
				<-ch
			}
		}()
	}
	time.Sleep(time.Second)  // 安全退出
}
// 使用管道来塞其他协程来实现抢占，使用休眠实现安全退出，这种方案是可靠的，同理，最好能够使用WaitGroup来实现安全退出