Go-3:Go语言的并发

go线程-GO ROUTINE

Go 程（goroutine）是由 Go 运行时管理的轻量级线程，使用方式：

package main

import (
	"fmt"
	"time"
)

func say(s string) {
	for i := 0; i < 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
}

func main() {
	go say("go routine say world")
	say("normal hello")
}

结果：

go routine say world
normal hello
normal hello
go routine say world
normal hello
go routine say world
normal hello
go routine say world
normal hello

信道 channel

信道方式

package main

import (
	"fmt"
)
func main() {
	s := []int{7, 2, 8, -9, 4, 0}
	c := make(chan int)
	//累加 7+2+8 = 17
	go sum(s[:len(s)/2], c)
	//累加 -9+4+0 = -5
	go sum(s[len(s)/2:], c)
	// 从 c 中接收。第一个参数给X第二个参数给Y
	// X -5 Y 17
	x, y := <-c, <-c
	fmt.Println(x, y, x+y)
}

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // 将和送入 c
}

结果

-5 17 12

带缓冲的信道

package main

import (
	"fmt"
)

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

//结果：
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
        D:/GO_WorkSpaces/twh/Thread.go:43 +0xa3

package main

import (
	"fmt"
)

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

//结果
1
2

信道的关闭和范围

package main

import (
	"fmt"
)

func fillChannel(n int, c chan int) {
	x, y := 0, 1
	// x 放入 channel x+y 后放入 channel
	for i := 0; i < n; i++ {
		fmt.Println("放入X:",x,",Y:",y,",x+y:",x+y)
		c <- x
		x, y = y, x+y
	}
	close(c)
}

func main() {
	// 构建channel c
	c := make(chan int, 10)
	go fillChannel(cap(c), c)
	for i := range c {
		fmt.Println(i)
	}
}

// 结果
放入X: 0 ,Y: 1 ,x+y: 1
放入X: 1 ,Y: 1 ,x+y: 2
放入X: 1 ,Y: 2 ,x+y: 3
放入X: 2 ,Y: 3 ,x+y: 5
放入X: 3 ,Y: 5 ,x+y: 8
放入X: 5 ,Y: 8 ,x+y: 13
放入X: 8 ,Y: 13 ,x+y: 21
放入X: 13 ,Y: 21 ,x+y: 34
放入X: 21 ,Y: 34 ,x+y: 55
放入X: 34 ,Y: 55 ,x+y: 89
0
1
1
2
3
5
8
13
21
34

select的使用

package main

import (
	"fmt"
)

func selectTest(channel, quit chan int) {
	x, y := 0, 1
	for {
		select {
		case channel <- x:
			fmt.Println("往channel推数据x：",x,";临时值y和x+y",y,x+y)
			x, y = y, x+y
		case <-quit:
			fmt.Println("quit")
			return
		}
	}
}

func main() {
	channel := make(chan int)
	quit := make(chan int)
	// 创建一个go程读取channel数据。10次后往quit信道塞数据。
	go func() {
		for i := 0; i < 10; i++ {
			fmt.Println(<-channel)
		}
		quit <- 0
	}()
	selectTest(channel, quit)
}
//结果
0
往channel推数据x： 0 ;临时值y和x+y 1 1
往channel推数据x： 1 ;临时值y和x+y 1 2
1
1
往channel推数据x： 1 ;临时值y和x+y 2 3
往channel推数据x： 2 ;临时值y和x+y 3 5
2
3
往channel推数据x： 3 ;临时值y和x+y 5 8
往channel推数据x： 5 ;临时值y和x+y 8 13
5
8
往channel推数据x： 8 ;临时值y和x+y 13 21
往channel推数据x： 13 ;临时值y和x+y 21 34
13
21
往channel推数据x： 21 ;临时值y和x+y 34 55

默认执行器

package main

import (
	"fmt"
	"time"
)

func main() {
	// 间隔100毫秒
	tick := time.Tick(100 * time.Millisecond)
	// 500好秒后执行
	boom := time.After(500 * time.Millisecond)
	for {
		select {
		case <-tick:
			fmt.Print("100毫秒.")
		case <-boom:
			fmt.Println("500毫秒-BOOM！!")
			return
		default:
			fmt.Print(".")
			time.Sleep(50 * time.Millisecond)
		}
	}
}
//结果
..100毫秒...100毫秒...100毫秒...100毫秒...500毫秒-BOOM！!