并发

/ More / Go / 并发

信道

存取时阻塞

ch <- v    // 将 v 发送至信道 ch。
v := <-ch  // 从 ch 接收值并赋予 v。

（“箭头”就是数据流的方向。）

和映射与切片一样，信道在使用前必须创建：

ch := make(chan int)

package main
import "fmt"

import "time"
func sum(s []int, c chan int) {

sum := 0

for _, v := range s {

sum += v

}

c <- sum // 将和送入 c

}
func main() {

s := []int{7, 2, 8, -9, 4, 0}
c := make(chan int)
go sum(s[:len(s)/2], c)
go sum(s[len(s)/2:], c)
		time.Sleep(10000 * time.Millisecond)

x, y := &lt;-c, &lt;-c // 从 c 中接收

fmt.Println(x, y, x+y)

}

带缓冲的

func main() {
	ch := make(chan int, 2)
	ch <- 1
	ch <- 2
	fmt.Println(<-ch)
	fmt.Println(<-ch)
}

v, ok := <-ch

循环 for i := range c 会不断从信道接收值，直到它被关闭。

close(c)

select

select 语句使一个 Go 程可以等待多个通信操作。

select 会阻塞到某个分支可以继续执行为止，这时就会执行该分支。当多个分支都准备好时会随机选择一个执行。

package main
import "fmt"
func fibonacci(c, quit chan int) {

x, y := 0, 1

for {

select {

case c <- x:

x, y = y, x+y

case <-quit:

fmt.Println("quit")

return

}

}

}
func main() {

c := make(chan int)

quit := make(chan int)

go func() {

for i := 0; i < 10; i++ {

fmt.Println(<-c)

}

quit <- 0

}()

fibonacci(c, quit)

}

加上default后就不堵塞了，就需要自己控制好间隔了

select {
	case i := <-c:
	    // 使用 i
	default:
	    // 从 c 中接收会阻塞时执行
}

并发

评论区