Go语言学习-并发

本文参考：

Go语言之旅
Go By Example
Go入门指南

Go协程

Go 程（goroutine）是由 Go 运行时管理的轻量级线程。

package main

import (
	"fmt"
	"time"
)

func fn(from string) {
	for i := 0; i < 3; i++ {
		fmt.Println(from, ":", i)
	}
}

func main() {
	// 直接调用函数fn
	fn("direct")
	
	// 开启go程调用函数fn
	go fn("goroutine")
	
	// 开启go程调用匿名函数
	go func(msg string) {
		fmt.Println(msg)
	}("going")

	time.Sleep(time.Second)
	fmt.Println("finished")
}

信道

协程是相互独立的，但是可以通过信道实现协程之间的通信，同一时间只有一个协程可以访问数据，所以不会出现数据竞争。
信道的声明：

ch1 := make(chan string)
var ch2 chan int
ch2 = make(chan int)

发送和接收：

ch <- int1 // 将int1发送给信道ch
int2 := <-ch // 获取信道ch中的下一个值FIFO

package main

import "fmt"

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)
	x, y := <-c, <-c // 从 c 中接收

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

Select语句

select可以从不同的并发执行的协程中获取值。

select {
case u:= <- ch1:
        ...
case v:= <- ch2:
        ...
        ...
default: // no value ready to be received
        ...
}

select做的是：

• 如果都阻塞了，会等待直到其中一个可以处理
• 如果多个可以处理，随机选择一个
• 如果没有通道操作可以处理并且写了 default 语句，它就会执行

在 select 中使用发送操作并且有 default 可以确保发送不被阻塞。如果没有 case，select 就会一直阻塞。

select 语句实现了一种监听模式，通常用在（无限）循环中；在某种情况下，通过 break 语句使循环退出。

有 2 个通道 ch1 和 ch2，三个协程 pump1()、pump2() 和 suck()。这是一个典型的生产者消费者模式。在无限循环中，ch1 和 ch2 通过 pump1() 和 pump2() 填充整数；suck() 也是在无限循环中轮询输入的，通过 select 语句获取 ch1 和 ch2 的整数并输出。选择哪一个 case 取决于哪一个通道收到了信息。程序在 main 执行 1 秒后结束。

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)

    go pump1(ch1)
    go pump2(ch2)
    go suck(ch1, ch2)

    time.Sleep(1e9)
}

func pump1(ch chan int) {
    for i := 0; ; i++ {
        ch <- i * 2
    }
}

func pump2(ch chan int) {
    for i := 0; ; i++ {
        ch <- i + 5
    }
}

func suck(ch1, ch2 chan int) {
    for {
        select {
        case v := <-ch1:
            fmt.Printf("Received on channel 1: %d\n", v)
        case v := <-ch2:
            fmt.Printf("Received on channel 2: %d\n", v)
        }
    }
}

输出：

Received on channel 2: 5
Received on channel 2: 6
Received on channel 1: 0
Received on channel 2: 7
Received on channel 2: 8
Received on channel 2: 9
Received on channel 2: 10
Received on channel 1: 2
Received on channel 2: 11
...
Received on channel 2: 47404
Received on channel 1: 94346
Received on channel 1: 94348

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

输出：

1
1
2
3
5
8
13
21
34
quit