golang 使用select和channel实现协程通信、并发控制和超时控制

select是golang中的控制语句,和switch有点类似,但是使用场景和原理却是完全不同,使用select配合channel可以实现协程之间的通信,也可以实现io层面的超时控制,也可以实现对于并发的控制

一、语法特点

1、select中的每个case都必须是一个通道
2、多个case中的通道,哪个符合就执行哪个通道,如果没有没有符合的case,要看是否有设置了default,如果有设置了default,就执行default中的逻辑,如果没有设置default,就会一直阻塞至其中的case被执行

二、实现协程之间的通信

子协程向主协程通信

如下,main函数中定义了一个select,其中设置了一个通道的case,从ch通道中获取数据。
main函数执行到select会阻塞,直到获取通道的值,这时候通过子协程,对ch进行赋值,所以会先打印child,后打印select start

ch := make(chan int) 
    go func() {
        fmt.Println("child")
        time.Sleep(2 * time.Second)
        ch <- 1
    }()

    select {
    case res := <-ch:
        fmt.Println("select start")
        fmt.Println(res)
    }

输出如下


image.png
子协程向其他子协程通信

这边定义了一个子协程,对childCh通道写数据,另一个子协程在for无限循环中不断的获取childCh通道的值,如果有值,则打印得到的值

    childCh := make(chan int)
    go func() {
        for {
            select {
            case res := <-childCh:
                fmt.Println("child2")
                fmt.Println(res)
            }
        }
    }()
    go func() {
        fmt.Println("child")
        time.Sleep(2 * time.Second)
        childCh <- 1
    }()
    for {
        time.Sleep(time.Second)
    }

输出如下:


image.png
多个子协程向主函数通信

如下,定义了两个通道,select会在两个通道随机选择,哪个通道先准备好了数据,就执行哪个通道

ch1 := make(chan int)
    ch2 := make(chan int)
    go func() {
        fmt.Println("child2")
        ch2 <- 2
    }()
    go func() {
        fmt.Println("child1")
        ch1 <- 1
    }()

    for i := 0; i < 2; i++ {
        select {
        case res1 := <-ch1:
            fmt.Println("ch1")
            fmt.Println(res1)
        case res2 := <-ch2:
            fmt.Println("ch2")
            fmt.Println(res2)

        }
    }

以下,主函数main中定义了两个通道,select定义在for循环中,主函数不断的从ch1和ch2通道中获取数据,如果没有数据的话,则执行default,两个子协程则是不断的往通道中分别写入 from 1和from 2数据。

    // 定义两个通道
    ch1 := make(chan string)
    ch2 := make(chan string)

    // 启动两个 goroutine,分别从两个通道中获取数据
    go func() {
        for {
            ch1 <- "from 1"
        }
    }()
    go func() {
        for {
            ch2 <- "from 2"
        }
    }()

    // 使用 select 语句非阻塞地从两个通道中获取数据
    for {
        select {
        case msg1 := <-ch1:
            fmt.Println(msg1)
        case msg2 := <-ch2:
            fmt.Println(msg2)
        default:
            // 如果两个通道都没有可用的数据,则执行这里的语句
            fmt.Println("no message received")
        }
    }

三、实现io的超时控制

这边使用的是select+channel+time.After实现了超时控制,这边列的只是简单的demo,io逻辑可以类似如下代码,放在do函数中,当io请求时间超过了time.After定义的时间,就会输出timeout

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个可以取消的上下文

    // 定义两个通道
    ch := make(chan string)

    go do(ch)

    select {
    case res := <-ch:
        fmt.Println("res")
        fmt.Println(res)
    case <-time.After(time.Second * 2):
        fmt.Println("timeout")
    }

}

func do(ch chan string) {
    time.Sleep(3 * time.Second)
    ch <- "done"
}

四、实现并发控制

适用场景:

比如某个逻辑getHttp中的逻辑只能允许一定的并发执行,当并发过高的时候会拖垮其中的服务或者外部服务时,我们就需要对并发进行控制。

这边创建了一个最多只能存放2个值的semaphoreBig通道,当并发到来的时候,通过semaphoreBig 信号量进行控制只能同时处理2个并发,多余的并发会阻塞至有空余的信号量后才会执行。

package main

import (
    "context"
    "fmt"
    "github.com/gin-gonic/gin"
)

var semaphoreBig = make(chan struct{}, 2) // 并发控制信号量

func main() {
    r := gin.Default() //创建gin

    r.Use(func(c *gin.Context) {
        //处理请求
        c.Next()
    })
    r.GET("/", index) //绑定路由

    r.Run(":8001") //运行绑定端口
}

func index(c *gin.Context) {
    Do(context.TODO())
}

func Do(ctx context.Context) {

    select {
    case <-ctx.Done():
        fmt.Println("ctx done")
    default:
        var releaseSemaphore func()
        semaphoreBig <- struct{}{}
        releaseSemaphore = func() {
            <-semaphoreBig // 释放信号量
        }
        func() {
            defer releaseSemaphore()
            getHttp()
        }()
    }
}

// 执行相应的http逻辑
func getHttp() {
    fmt.Println("http")
}

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容