demo1:

    1. const (
    2.     THREAD_NUM          int = 5
    3.     THREAD_PRINT        int = 0
    4.     THREAD_NEXT_STOPPED int = 1
    5.     THREAD_THIS_STOPPED int = 2
    6. )
    8. type Thread_pipline_printer struct {
    9.     idx       int
    10.     status    int
    11.     next_chan chan int
    12. }
    14. func (printer *Thread_pipline_printer) Print(max_num int, pre Thread_pipline_printer, wg *sync.WaitGroup) {
    15.     defer wg.Done()
    16.     for {
    17.         print_num := <-pre.next_chan
    18.         if print_num < max_num {
    19.             print_format(printer.idx, print_num)
    20.         }
    22.         if printer.status == THREAD_PRINT {
    23.             printer.next_chan <- (print_num + 1)
    24.         }
    26.         if print_num > max_num {
    27.             printer.status = THREAD_THIS_STOPPED
    28.             return
    29.         } else if print_num == max_num {//注意。。。。。。。。。。。
    30.             printer.status = THREAD_NEXT_STOPPED
    31.         }
    33.     }
    35. }
    37. func print_format(thread_idx int, print_num int) {
    38.     fmt.Printf("Printer%d-%d\n", thread_idx, print_num)
    39. }
    41. func Print() {
    43.     printers := make([]Thread_pipline_printer, THREAD_NUM)
    45.     for i := 0; i < THREAD_NUM; i++ {
    46.         printers[i] =
    47.             Thread_pipline_printer{i, THREAD_PRINT, make(chan int)}
    48.     }
    50.     start := 1
    51.     end := 100
    53.     wg := &sync.WaitGroup{}
    54.     wg.Add(THREAD_NUM)
    56.     for i := 0; i < THREAD_NUM; i++ {
    57.         input_num := (i + THREAD_NUM - 1) % THREAD_NUM
    58.         go printers[i].Print(end+1, printers[input_num], wg)
    59.     }
    61.     printers[THREAD_NUM-1].next_chan <- start
    62.     wg.Wait()
    64. }

    这段代码用Chanel将五个协程连接起来，最后注意打印完最后一个数字的协程不能立即关闭，需要将chanel传递一遍依次关闭。否则会造成死锁。

    demo2:

    1. func printer(i int, inCh chan int, outCh chan int, endNum int, wg *sync.WaitGroup) {
    2.     for {
    3.         n, ok := <-inCh
    4.         if !ok {
    5.             return
    6.         }
    7.         fmt.Printf("Printer-%d %d\n", i+1, n)
    8.         if n == endNum {
    9.             wg.Done()
    10.             return
    11.         }
    12.         outCh <- n + 1
    13.     }
    14. }
    16. func main() {
    17.     const n = 5
    18.     const endNum = 100
    20.     chs := make([]chan int, n)
    21.     for i := 0; i < n; i++ {
    22.         chs[i] = make(chan int)
    23.     }
    24.     wg := &sync.WaitGroup{}
    25.     wg.Add(1)
    26.     for i := 0; i < n; i++ {
    27.         inCh := chs[i]
    28.         outCh := chs[(i+1)%n]
    29.         go printer(i, inCh, outCh, endNum, wg)
    30.     }
    31.     chs[0] <- 1
    32.     wg.Wait()
    33.     for i := 0; i < n; i++ {
    34.         close(chs[i])
    35.     }
    36. }

    这段代码和上边道理是一样的，都是用channel将前后协程连接。这段代码按理说最后是会死锁的(跟第一段代码的注意事项是一个道理)。但是他waitgroup设置的是1，那就是说当有一个协程done了(打印最后一个数字的协程)，主协程就不再等待，运行下去结束后其他协程自然会结束。其实第一段代码也可以将waitgroup设置成1，在30行下边加个return，也能跟这段代码一样强制结束。不过这种方式可能不够优雅。