入门goroutine并发设计模式以及goroutine可视化工具

func f(left, right chan int) {
    // 这个函数就把right的输出和left的输入联系起来了。
    left <- 1 + <-right
}
func main() {
    const n = 10000
    leftmost := make(chan int)
    right := leftmost
    left := leftmost
    // 创建长度为n的daisy链
    for i := 0; i < n; i++ {
        right = make(chan int)
        go f(left, right)
        left = right
    }
    // 在链的最右端输入1，那么最左端就会得到10001
    go func(c chan int) { c <- 1 }(right)
    fmt.Println(<-leftmost)
}

import (
       "fmt"
       "os"
       "runtime/trace"
       "time"
)
func Generate(ch chan<- int) {
       for i := 2; ; i++ {
           ch <- i
           // 这是为了方便gotrace绘图
           time.Sleep(10 * time.Millisecond)
       }
}
func Filter(ch <-chan int, out chan<- int, prime int) {
       for {
           i := <-ch
           if i%prime != 0 {
               out <- i
           } else {
               fmt.Printf("[%d] filter out %d\n", prime, i)
           }
       }
}
func main() {
    // 这些也是gotrace要求插入的代码。下同
    trace.Start(os.Stderr)
       ch := make(chan int)
       go Generate(ch)
       for i := 0; i < 10; i++ {
           prime := <-ch   // step1
           fmt.Println(prime)
           out := make(chan int)   // step2 
           go Filter(ch, out, prime)  // step3
           ch = out   // step4
       }
       trace.Stop()
}

func main() {
    var Ball int
    table := make(chan int)
    go player("2", table)
    go player("1", table)
    // 首先把球放到“桌上”
    table <- Ball
    time.Sleep(1 * time.Second)
    // 1s后比赛结束……
    <-table
}
func player(id string, table chan int) {
    for {
        ball := <-table
        log.Printf("%s got ball[%d]\n", id, ball)
        time.Sleep(50 * time.Millisecond)
        log.Printf("%s bounceback ball[%d]\n", id, ball)
        ball++
        table <- ball
    }
}

    go player("2", table)
    go player("3", table)
    go player("1", table)

import (
       "fmt"
       "math/rand"
       "os"
       "runtime/trace"
       "time"
)
func main() {
       trace.Start(os.Stderr)
       c := fanIn(boring(1), boring(2))
       for i := 0; i < 10; i++ {
           fmt.Println(<-c)
       }
       fmt.Println("You're both boring; I'm leaving.")
       trace.Stop()
}
func fanIn(input1, input2 <-chan int) <-chan int {
       c := make(chan int)
       go func() { for {c <- <-input1} }()
       go func() { for {c <- <-input2} }()
       return c
}
func boring(msg int) <-chan int {
       c := make(chan int)
       go func() { // We launch the goroutine from inside the function.
           for i := 0; ; i++ {
               c <- msg*1000 + i
               time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)
           }
       }()
       return c // Return the channel to the caller.
}

import (
    "fmt"
    "os"
    "runtime/trace"
    "sync"
    "time"
)
func worker(ch <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for {
        task, ok := <-ch
        if !ok {
            return
        }
        time.Sleep(20 * time.Millisecond)
        fmt.Println("processing task", task)
    }
}
func pool(wg *sync.WaitGroup, workers, tasks int) {
    ch := make(chan int)
    for i := 0; i < workers; i++ {
        time.Sleep(1 * time.Millisecond)
        // spawn出很多worker线程
        go worker(ch, wg)
    }
    for i := 0; i < tasks; i++ {
        time.Sleep(10 * time.Millisecond)
        // 开始分发任务，被激活的workers开始工作了
        ch <- i
    }
    close(ch)
}
func main() {
    trace.Start(os.Stderr)
    var wg sync.WaitGroup
    wg.Add(36)
    go pool(&wg, 36, 36)
    wg.Wait()
    trace.Stop()
}

import (
       "fmt"
       "net"
       "os"
       "runtime/trace"
       "time"
)
func handler(c net.Conn, ch chan int) {
   ch <- len(c.RemoteAddr().String())
   time.Sleep(10 * time.Microsecond)
   c.Write([]byte("ok"))
   c.Close()
}
func logger(ch chan int) {
       for {
           time.Sleep(1500 * time.Millisecond)
           fmt.Println(<-ch)
       }
}
func server(l net.Listener, ch chan int) {
       for {
           c, err := l.Accept()
           if err != nil {
               continue
           }
           go handler(c, ch)
       }
}
func main() {
       trace.Start(os.Stderr)
       l, err := net.Listen("tcp", ":5000")
       if err != nil {
           panic(err)
       }
       ch := make(chan int)
       go logger(ch)
       go server(l, ch)
       time.Sleep(10 * time.Second)
       trace.Stop()
}

import (
           "fmt"
           "net"
           "os"
           "runtime/trace"
           "time"
)
func handler(c net.Conn, ch chan int) {
       ch <- 0
       time.Sleep(50 * time.Microsecond)
       c.Write([]byte("ok"))
       c.Close()
}
func logger(wch chan int) {
       for {
           fmt.Println(<-wch)
           // 这里主要耗时
           time.Sleep(1500 * time.Millisecond)
       }
}
func pool(ch chan int, n int) {
       wch := make(chan int)
       for i := 0; i < n; i++ {
           go logger(wch)
       }
       for {
           wch <- <-ch
       }
}
func server(l net.Listener, ch chan int) {
       for {
           c, err := l.Accept()
           if err != nil {
               continue
           }
           go handler(c, ch)
       }
}
func main() {
       trace.Start(os.Stderr)
       l, err := net.Listen("tcp", ":5000")
       if err != nil {
           panic(err)
       }
       ch := make(chan int)
       go pool(ch, 36)
       go server(l, ch)
       time.Sleep(10 * time.Second)
       trace.Stop()
}