GO语言基础语法之并发 (第二十三天）

并行与并发

并发：一个时间段内有很多的线程或进程在执行，但何时间点上都只有一个在执行，多个线程或进程争抢时间片轮流执行，多线程模型
并行：一个时间段和时间点上都有多个线程或进程在执行，需要多个核心处理器（CPU）

Go 并发

Go 语言并发，通过 go 关键字来开启 goroutine ，goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。
goroutine 语法格式：
go 函数名( 参数列表 )
例如：
go fast(x, y, z) //开启一个新的 goroutine

同一个程序中的所有 goroutine 共享同一个地址空间

package main

import (
	"fmt"
)

func printfString(s string) {
	for i := 0; i < 2; i++ {
		//time.Sleep(1 * time.Millisecond)
		fmt.Println(s)
	}
}

func main() {
	go printfString("3333")
	go printfString("4444")
	go printfString("1111")
	printfString("2222")

}

• 并发执行，执行的顺序不确定
• main 函数执行完成后退出后，可能协程还未退出
• 一个内核线程对应用户态多个goroutine，goroutine和OS线程是多对多的关系。

通道（channel）

-定义：通道（channel）是用来传递数据的一个数据结构。一个 channel是一个通信机制，每个 channel 都有类型（发送/接受数据的类型）。列如:发送 int 类型数据的 channel : chan int。

• 创建：
  ch := make(chan int)
• 含义解释：
  操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。
  ch <- v // 把 v 发送到通道 ch
  v := <-ch // 从 ch 接收数据// 并把值赋给 v

默认情况下，通道是不带缓冲区的。无缓冲的通道必须有接收才能发送,发送端发送数据，同时必须有接收端相应的接收操作。

不带缓存的：

package main

import (
	"fmt"
	"math/rand"
)

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // 把 sum 发送到通道 c
}

func main() {
	var s [10000000]int
	for i := 0; i< 10000000;i++ {
		s[i]= rand.Int()
	}

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

671395704509779677 -7495381818067143779 -6823986113557364102

Process finished with exit code 0

• channel操作
  发送（send）、接收(receive）和关闭（close）
  发送和接收都使用<-符号。

1.定义初始化
ch := make(chan int)

2.发送，将一个值发送到通道中。
ch <- 10 // 把10发送到ch中

3.接收，从一个通道中接收值。
x := <- ch // 从ch中接收值并赋值给变量x
<-ch // 从ch中接收值，忽略结果

4.关闭
调用内置的close函数关闭通道。
close(ch) //关闭通道不是必须的。

5.关闭后的通道特点：

对一个关闭的通道再发送值就会导致panic。
对一个关闭的通道进行接收会一直获取值直到通道为空。
对一个关闭的并且没有值的通道执行接收操作会得到对应类型的零值。
关闭一个已经关闭的通道会导致panic。

package main

import (
	"fmt"
)

func a() {
	i := 0
	defer fmt.Println(i) //在return 时候执行的栈空间的函数动作，此时的空间i 的值为0
	i++
	return
}

func recv(c chan int) {
	ret := <-c
	fmt.Println("recv ch sucessed", ret)
}

func main() {
	a()

	ch := make(chan int) //不携带缓存的（默认的channel），需要先定义一个处理接受的
	go recv(ch)
	ch <- 10
	fmt.Println("send ch sucessed")

}

API server listening at: 127.0.0.1:31820
0
recv ch sucessed 10
send ch sucessed
Process exiting with code: 0

• 有缓冲的通道
  通道的容量大于零，该通道就是有缓冲的通道，通道的容量表示通道中能存放元素的数量。使用内置的len函数获取通道内元素的数量，cap函数获取通道的容量。

package main

import (
	"fmt"
)

func Recv(c chan int) {

	sum := <-c
	fmt.Println("Recv sucessed", sum)
}

func main() {

	ch := make(chan int, 1) // 创建一个容量为1的有缓冲区通道
	ch <- 10
	Recv(ch)
	fmt.Println("Send sucessed")

}

```go
API server listening at: 127.0.0.1:22864
Recv sucessed 10
Send sucessed
Process exiting with code: 0

GO语言中defer使用

将一个方法延迟到包裹该方法的方法返回时执行时候执行，
类似java C++ 的try…catch… ，C# using 的作用，有时候也用来处理关闭文件句柄等回收操作。

触发时机：
1.包裹defer的函数返回时
2.包裹defer的函数执行到末尾时
3.所在的goroutine发生panic时

package main

import (
	"fmt"
)

func a() {
	i := 0
	defer fmt.Println(i)  //压入栈空间时候i 已经等于0
 	i++
	return
}

func main() {
	a()
	return
}

API server listening at: 127.0.0.1:38494
0
Process exiting with code: 0