go语言channel的别样用法

1.返回值使用通道

func main() {
    // 生成随机数作为一个服务
    randService := randGenerator()
    // 从服务中读取随机数并打印
    fmt.Printf("%d\n",<-randService)
}
func randGenerator() chan int {
    // 创建通道
    out := make(chan int)
    // 创建协程
    go func() {
        for {
            //向通道内写入数据，如果无人读取会等待
            out <- rand.Int()
        }
    }()
    return out
}

2.参数使用通道

//一个查询结构体
type query struct {
    //参数Channel
    sql chan string
    //结果Channel
    result chan string
}
//执行Query
func execQuery(q query) {
    //启动协程
    go func() {
        //获取输入
        sql := <-q.sql
        //访问数据库，输出结果通道
        q.result <- "get" + sql
    }()
}
func main() {
    //初始化Query
    q := query{make(chan string, ),make(chan string, )}
    //执行Query，注意执行的时候无需准备参数
    execQuery(q)
    //准备参数
    q.sql <- "select * from table"
    //获取结果
    fmt.Println(<-q.result)
}

3.并发循环

func doSomething(num int) (sum int) {
    for i := ; i <= ; i++ {
        fmt.Printf("%d + %d = %d\n", num, num + i, num + num + i)
        sum = sum + num + i
    }
    return sum
}
func testLoop() {
    // 建立计数器，通道大小为cpu核数
    var NumCPU = runtime.NumCPU()
    fmt.Printf("NumCPU = %d\n", NumCPU)
    sem :=make(chan int, NumCPU);
    //FOR循环体
    data := []int{, , , , , , , , , }
    for _,v:= range data {
        //建立协程
        go func (v int) {
            fmt.Printf("doSomething(%d)...\n", v)
            sum := doSomething(v);
            //计数
            sem <- sum;
        } (v);
    }
    // 等待循环结束
    var total int =
    for i := ; i < len(data); i++ {
        temp := <- sem
        fmt.Printf("%d <- sem\n", temp)
        total = total + temp
    }
    fmt.Printf("total = %d\n", total)
}
func main() {
    testLoop()
}

4.利用channel计算素数

// Send the sequence 2, 3, 4, ... to channel 'in'.
func Generate(ch chan int) {
    for i := ; ; i++ {
        ch<- i // Send 'i' to channel 'in'.
    }
}
// Copy the values from channel 'in' to channel 'out',
// removing those divisible by 'prime'.
func Filter(in chan int, out chan int, prime int) {
    for {
        i := <-in // Receive valuefrom 'in'.
        if i%prime !=  {
            out <- i // Send'i' to 'out'.
        }
    }
}
func main() {
    in := make(chan int)
    go Generate(in)      // Launch Generate goroutine.
    for i := ; i < ; i++ {
        prime := <-in
        print(prime, "\n")
        out := make(chan int)
        go Filter(in, out, prime)
        in = out
    }
}

5.共享变量的读写

//共享变量有一个读通道和一个写通道组成
type shardedVar struct {
    reader chan int
    writer chan int
}
//共享变量维护协程
func whachdog(v shardedVar) {
    go func() {
        //初始值
        var value int =
        for {
            //监听读写通道，完成服务
            select {
            case value = <-v.writer:
            case v.reader <-value:
            }
        }
    }()
}
func main() {
    //初始化，并开始维护协程
    v := shardedVar{make(chan int), make(chan int)}
    whachdog(v)
    //读取初始值
    fmt.Println(<-v.reader)
    //写入一个值
    v.writer <-
    //读取新写入的值
    fmt.Println(<-v.reader)
}

还可以访问我树莓派上搭的博客地址：

http://www.codeforfun.info/