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")
}