1并发concurrency
goroutine是由官方实现的超级线程池，每个实例4-5kb的栈内存占用和用于实现机制而大幅减少的创建和销毁开销，是制造go号称的高并发的根本原因。
并发不是并行，并发主要由切换时间片来实现“同时运行，在并行则是直接利用多核实现多线程的运行，但go可以设置使用核数，以发挥多核计算机的能力；
goroutine奉行通过通信来共享内存，而不是共享内存来通信。
import (
"fmt"
"time"
)
func main() {
go Go()
time.Sleep(2 * time.Second)
}
func Go(){
fmt.Println("Go Go Go！！")
}
上面程序中在用并发调用Go后，需要休眠2秒这样才能顺利打印，否则还没有执行Go，main已经执行完毕然后退出程序了。
2Channel和Select
2.1Channel
1.Channel是goroutine沟通的桥梁，大都是阻塞同步的
2.通过make创建，close关闭，关闭后不能写，但可以读
3.Channel是引用类型
4.可以使用for range来迭代不断操作channel
5.可以设置单向或双向通道
6.可以设置缓存大小，在未被填满前不会发生阻塞。
- chan可以声明成可读可写的，只读的，只写的三种。var ch1 chan int(可读可写)，var ch2 chan<- int(只写)，var ch3 <-chan int(只读)。
import (
"fmt"
)
func main() {
# 创建一个通道c，值为布尔型
c := make(chan bool)
# go运行匿名函数
go func(){
fmt.Println("Go Go Go！！")
# 在通道中存入一个值true
c <- true
}()
# 在通道中取出值
<-c
}
main函数执行到匿名函数处。进行异步运行(go关键字表示异步)，在匿名函数执行的同时执行到<-c，<-c表示等待c变量填充的有值后在继续运行(相当于python多线程中的join等待操作)，故在此处等待c填充，直到匿名函数执行完后，使用c <- true向c填充值，然后<-c收到信号main函数继续向下运行
频道无缓存，取操作(<-c)需要在写操作(c <- true)前面,即位于main函数下；有缓存则反之
# for range迭代通道
func main() {
c := make(chan bool)
go func(){
fmt.Println("Go Go Go！！")
c <- true
close(c)
}()
for v := range c{
# 取出存入的值true
fmt.Println(v)
}
}
# 程序运行流程，先调用异步函数的同时，在for循环处等待，当存入为true时，for接收到信息，打印true，然后又进行循环，接收到close信号，关闭异步程序
当有多个异步处理任务时，等待所有执行完在往下执行
func main() {
# runtime.GOMAXPROCS设置异步处理用的进程个数,runtime.NumCPU获取cpu个数
# 不设置此句，也能异步运行
runtime.GOMAXPROCS(runtime.NumCPU())
c := make(chan bool, 10)
for i:=0;i<10;i++{
go Go(c, i)
}
# 由于频道设置的缓存为10个，所以遍历这10个，等每一个都取的有值，程序在向下执行
for i:=0;i<10;i++{
<-c
}
}
func Go(c chan bool, index int){
a := 1
for i:=0;i<100000;i++{
a += 1
}
fmt.Println(index, a)
c <- true
}
不使用channel,使用WaitGroup进行通信达到异步任务全部执行完方退出程序
func main() {
//runtime.GOMAXPROCS(runtime.NumCPU())
# 建立一个任务组
wg := sync.WaitGroup{}
# 添加10个任务
wg.Add(10)
for i:=0;i<10;i++{
# 将任务组的地址传递给任务(传地址效率高一点)
go Go(&wg, i)
}
# 在此处等待任务全部执行完毕
wg.Wait()
}
func Go(wg *sync.WaitGroup, index int){
a := 1
for i:=0;i<100000;i++{
a += 1
}
fmt.Println(index, a)
# 通知任务组，该任务执行完毕
wg.Done()
}
2.2Select
1.可处理一个或多个channel的发送与接收；
2.同时有多个可用的channel时按随机顺序处理；
3.可用空的select来阻塞main函数；
4.可设置超时。
func main() {
//runtime.GOMAXPROCS(runtime.NumCPU())
# 创建两个channel用于select
c1, c2 := make(chan int), make(chan string)
# 单独创建一个channel用于检查前两个channel是否关闭
o := make(chan bool)
go func(){
# 用一个死循环执行select代码，否则执行一次就会退出
for {
select {
case v, ok := <-c1:
# 如果c1中没有值则向o中写入值，并且跳出c1的循环
if !ok{
o <- true
break
}
fmt.Println("c1", v)
case v,ok := <-c2:
# 如果c2中没有值则向o中写入值，并且跳出c1的循环
if !ok{
o <- true
break
}
fmt.Println("c2", v)
}
}
}()
c1 <- 1
c2 <- "hi"
c1 <- 3
c2 <- "hello"
# 停止向c1中写入值，不停止则会一直写入0或者""
close(c1)
close(c2)
<-o
}
使用缓存channe监听异步任务完成否
func main() {
c1, c2 := make(chan int), make(chan string)
o := make(chan bool, 2)
go func(){
for {
select {
case v, ok := <-c1:
if !ok{
o <- true
break
}
fmt.Println("c1", v)
case v,ok := <-c2:
if !ok{
o <- true
break
}
fmt.Println("c2", v)
}
}
}()
c1 <- 1
c2 <- "hi"
c1 <- 3
c2 <- "hello"
close(c1)
for i:=0;i<2;i++{
<-o
}
}
随机输出结果，死循环，将一直运行(使用空的select阻塞main函数)
func main() {
c := make(chan int)
go func(){
for v := range c{
fmt.Println(v)
}
}()
for{
select{
case c <-0:
case c <-1:
}
}
}
设置超时
func main() {
c:= make(chan bool)
select {
case v:=<-c:
fmt.Println(v)
# 设置超时3秒，After返回一个channel
case <-time.After(3*time.Second):
fmt.Println("Timeout")
}
}
两个互相发消息的channel，接收到消息后，则发一个消息
# 定义一个全局变量
var c chan string
func PingPong(){
i := 0
#进入死循环一直监听，当主程序10次发完退出时结束
for {
fmt.Println(<-c)
c <- fmt.Sprintf("from pingping: hi,%d", i)
i++
}
}
func main(){
# 初始化全局变量
c = make(chan string)
go PingPong()
# 发送10次
for i:=0;i<10;i++{
c <- fmt.Sprintf("from main:hello, %d", i)
fmt.Println(<-c)
}
}
网友评论