Go管道初识

Go管道基础知识

管道分类

无缓冲(unbuffered channel)
1. 无缓冲的通道是指在接收前没有能力保存任何值的通道(最多一个数据)
2. 构建 unbuffered := make(chan int) // 管道内值类型
3. 阻塞条件阻塞条件,发送时管道内有值阻塞,接收时管道内无值阻塞
有缓冲(buffered channel)
1. 有缓冲的通道是一种在被接收前能存储一个或者多个值的通道(类似于队列)
2. 构建 buffered := make(chan string, 10) // 管道内值类型, 管道大小
3. 阻塞条件,发送时管道内满阻塞,接收时管道内无值阻塞

管道赋值与取址

unbuffered := make(chan int)
unbuffered <- 1 // 将1写入管道
out := <- unbuffered // 将值从管道当中取出

无缓存管道实例

击球类型

模拟击球比赛

package main

import (
    "sync"
    "math/rand"
    "time"
    "fmt"
)

// 用来等待程序结束
var wg sync.WaitGroup

func init()  {
    rand.Seed(time.Now().UnixNano())
}

func main()  {
    // 创建一个无缓存管道
    court := make(chan int)

    // 计数器加2, 表示要等待两个goroutine
    wg.Add(2)

    // 启动两个玩家
    go player("lin", court)
    go player("lv", court)

    // 发球(初始化管道内数据)
    court <- 1

    // 等待游戏结束
    wg.Wait()
}

func player(name string, court chan int)  {
    // 在函数退出时通知mian函数工作已经完成
    defer wg.Done()
    for {
        // 等待球被击打过来(ball 管带内数据, ok 管道返回标志)
        ball, ok := <-court
        if !ok {
            fmt.Printf("Player %s Won\n", name)
            return
        }
        // 取随机数模仿是否成功击打
        n := rand.Intn(100)
        if n%14 == 0 {

            fmt.Printf("Player %s Missed\n", name)
            // 击打失败关闭管道(比赛结束)
            close(court)
            return
        }

        fmt.Printf("Player %s Hit %d\n", name, ball)
        // 击球数加一, 击球数写入管道
        ball++
        court <- ball
    }
}

模拟赛跑

package main

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

var wg sync.WaitGroup

func main()  {
    baton := make(chan int)

    wg.Add(1)

    go Runner(baton)

    baton <- 1
    wg.Wait()
}

func Runner(baton chan int)  {
    var newRunner int
    // 从管道中取值
    runner := <- baton

    fmt.Printf("运动员 %d 号开始赛跑\n", runner)

    if runner != 4 {
         newRunner = runner + 1
         fmt.Printf("运动员 %d 在跑道上准备接力\n", newRunner)
         go Runner(baton) // 创建goruntine(可是会在管道取值那阻塞,等待管道当中添加值baton <- newRunner)
    }

    time.Sleep(100 * time.Millisecond)

    if runner == 4 {
        fmt.Printf("运动员 %d 号 完成最后一棒,结束比赛\n", runner)
        wg.Done()
        return
    }

    fmt.Printf("运动员 %d 将交接棒递到 %d 手中\n", runner, newRunner)
    baton <- newRunner
}

有缓冲管道

package main

import (
    "sync"
    "fmt"
    "time"
    "math/rand"
)

const (
    numberWorker = 4 // 消费者数量,即goroutine数量
    taskLoad = 10 // 待处理数量
)

var wg sync.WaitGroup

func init() {
    rand.Seed(time.Now().Unix())
}

func main()  {

    tasks := make(chan string, taskLoad)

    wg.Add(numberWorker)

    for gr := 1; gr <= numberWorker; gr++ {
        go worker(tasks, gr)
    }

    for post := 1; post <= taskLoad; post++ {
        tasks <- fmt.Sprintf("task: %d", post)
    }
    close(tasks)
    wg.Wait()
}

func worker(tasks chan string, worker int)  {

    defer wg.Done()
    for {
        // 获取任务
        task, ok := <- tasks
        if !ok {
            fmt.Printf("%d 工作人员已经结束工作\n", worker)
            return
        }

        fmt.Printf("%d 号工作人员开始 %s工作\n", worker, task)

        // 随机等待一段时间
        sleep := rand.Int63n(100)
        time.Sleep(time.Duration(sleep) * time.Millisecond)
        fmt.Printf("%d 号工作人员已经完成了 %s 工作\n", worker, task)
    }
}