Go 学习笔记08.协程和管道

￡神魔★判官ぃ 2023-05-22 11:27 7阅读 0赞

## go 协程 ##

package main
    
    import "fmt"
    
    func f(from string) { 
        for i := 0; i < 3; i++ { 
            fmt.Println(from, ":", i)
        }
    }
    
    func main() { 
    
        // 正常调用方法
        f("normal")
    
        // 协程
        // go f()
        go f("go")
    
        // go 匿名函数(going)
        go func(msg string) { 
            fmt.Println(msg)
        }("going")
    
        // 等待输入，我们阻塞一下
        // 如果不阻塞，协程来不及执行，主程序就会退出了
        var input string
        fmt.Scanln(&input)
        fmt.Println("done")
    }

## 管道 ##

> 管道用来连接多个协程，收发数据

package main
    
    import "fmt"
    
    func main() { 
    
        // 创建一个管道
        // 管道中传输的数据是string, 管道使用chan关键字
        messages := make(chan string)
    
        // 看箭头的方向， 下面的是向管道内输入数据
        go func() {  messages <- "ping" }()
    
        // 从管道中接收数据
        msg := <-messages
        fmt.Println(msg)
    }
    
    // 默认发送和接收操作是阻塞的，直到发送方和接收方都准备完毕。

## 缓冲管道 ##

> 缓冲管道与普通无缓冲管道的区别
> 
> 简单说 缓冲管道，可以设定管道可存信息的大小
> 
> 无缓冲普通的，大小就是1，有一个消息不取出就无法再次放入
> 
> ps: 测试是无缓冲管道，连续放入两个编译或执行的时候会报错
> 
> fatal error: all goroutines are asleep - deadlock!
> 
> goroutine 1 \[chan send\]:
> 
> https://blog.csdn.net/sgsgy5/article/details/82054902

package main
    
    import "fmt"
    
    func main() { 
    
        // 设置缓冲管道大小2
        messages := make(chan string, 2)
    
        // 发送
        messages <- "buffered"
        messages <- "channel"
    
        // 接收
        fmt.Println(<-messages)
        fmt.Println(<-messages)
    }

## 管道同步 ##

package main
    
    import "fmt"
    import "time"
    
    
    func worker(done chan bool) { 
        fmt.Print("working...\n") // fmt.Print 不会换行，而Println会换行
        time.Sleep(time.Second)
        fmt.Println("done")
        // 发送一个值来通知我们已经完工啦。
        done <- true
    }
    
    func main() { 
    
        // 创建管道，管道容量1 接收参数布尔类型
        // 用这个管道阻塞住主进程，这样就可以其到协程管道同步的效果了
        done := make(chan bool, 1)
        go worker(done)
    
        // 阻塞住，直到worker协程执行完毕后向管道中发送消息
        <-done
    }

## 管道方向 ##

> select case
> 
> 管道chan作为参数 传入到函数时
> 
> 可以规定这个管道 只能发 或 只能收，当然还可以不做限制

package main
    
    import "fmt"
    
    // pings是管道，通过箭头的方向，我们可以猜到 这个限制的是 只能向管道里传入值
    // 也就是只能发chan-< 
    // 如果这样 <-chan 就行只能收
    func ping(pings chan<- string, msg string) { 
        pings <- msg
    }
    
    // 两个管道，一个只能发，一个只能收
    func pong(pings <-chan string, pongs chan<- string) { 
        msg := <-pings
        pongs <- msg
    }
    
    func main() { 
        pings := make(chan string, 1)
        pongs := make(chan string, 1)
        ping(pings, "passed message")
        pong(pings, pongs)
        fmt.Println(<-pongs)
    }

## 管道选择器 ##

> select…case
> 
> 管道选择器可以让我们同时等待多个管道操作
> 
> 通常 go协程+管道+管道选择器 结合是Go一个强大的特性

> 感觉和python的异步协程中的loop差不多

package main
    
    import "time"
    import "fmt"
    
    func main() { 
    
        // 创建2个管道
        c1 := make(chan string)
        c2 := make(chan string)
    
        // go协程 执行匿名函数，休眠1秒，传入one
        go func() { 
            time.Sleep(time.Second * 1)
            c1 <- "one"
        }()
        // 休眠2秒，传入two
        go func() { 
            time.Sleep(time.Second * 2)
            c2 <- "two"
        }()
    
        // 使用关键字 select..case 
        // 哪个先完成，就先执行哪个case，然后向下执行
        // 所以我们这里循环了2次，目的是让他们都得到执行，最后耗时应该是2秒多一点点，不会是3秒
        for i := 0; i < 2; i++ { 
            select { 
            case msg1 := <-c1:
                fmt.Println("received", msg1)
            case msg2 := <-c2:
                fmt.Println("received", msg2)
            }
        }
    }