golang 并发

Golang 并发

• 并行 指的是在同一时刻 有多条指令在多个CPU处理器上同时执行 2个任务2个窗口需要硬件支持
  
• 并发是指在同一时刻 只能有一条指令 单多个进程指令快速轮换执行 2个队伍1个窗口 要求提升软件能力
  

Golang 并发优势

• go 从底层就支持并发
  
• 简化了并发程序的编写方法
  

Goroutine 是什么

• 它是go 并发设计的核心
  
• goroutine就是协程，它比线程更小，十几个goroutine 在底层可能就是五六个线程
  
• go 语言内部实现了goroutine的内存共享，执行goroutine只需极少的栈内存(大概4-5KB)
  

创建goroutine

• 只需要在语句前添加go 关键字即可
  

1.     package main
3.     import (
4.     "fmt"
5.     "time"
6.     )
8.     //测试协程
9.     //循环打印内容
10.     func newTask() {
11.     i := 0
12.     for {
13.     i++
14.     fmt.Printf("new goroutine\:i=%d\n", i)
15.     time.Sleep(1 \* time.Second)
16.     }
17.     }
19.     //main()相当于是主协程
20.     func main() {
21.     //启动子协程
22.     go newTask()
23.     i := 0
24.     for {
25.     i++
26.     fmt.Printf("main goroutine\:i=%d\n", i)
27.     time.Sleep(1 \* time.Second)
28.     }
29.     }

复制代码

• 开发人员无需了解任何执行细节，调度器会自动将其安排到合适的系统线程上运行
  
• 如果主协程推出，所有子进程协程都会退出
  

1.     package main
2.     import (
3.     "fmt"
4.     "time"
5.     )
6.     //main()相当于是主协程
7.     func main() {
8.     //匿名子协程
9.     go func() {
10.       i := 0
11.       for {
12.         i++
13.         fmt.Println("子协程 i=", i)
14.         time.Sleep(1 \* time.Second)
15.       }
16.     }()
17.     i := 0
18.     for {
19.       i++
20.       fmt.Println("主协程 i=", i)
21.       time.Sleep(1 \* time.Second)
22.       //主协程第二次后退出
23.       if i == 2 {
24.         break
25.       }
26.     }
27.     }

复制代码

• 程序没任何输出，也不报错
  

1.     package main
3.     import (
4.     "fmt"
5.     "time"
6.     )
8.     //main()相当于是主协程
9.     func main() {
10.     //匿名子协程
11.     go func() {
12.     i := 0
13.     for {
14.     i++
15.     fmt.Println("子协程 i=", i)
16.     time.Sleep(1 \* time.Second)
17.     }
18.     }()
19.     }

复制代码

runtime 包

• runtime.Gosched(): 用于让出CPU时间片，调度器重新安排任务调度，还是有几率分配到它的
  

1.     package main
3.     import (
4.     "fmt"
5.     "runtime"
6.     )
8.     func main() {
9.     //匿名子协程
10.     go func(s string) {
11.     for i := 0; i < 2; i++ {
12.     fmt.Println(s)
13.     }
14.     }("world")
15.     //主协程
16.     for i := 0; i < 2; i++ {
17.     runtime.Gosched()
18.     fmt.Println("hello")
19.     }
20.     }

复制代码

• runtime.Goexit() 立即终止当前协程
  

1.     package main
3.     import (
4.     "fmt"
5.     "time"
6.     "runtime"
7.     )
9.     func main() {
10.     //匿名子协程
11.     go func() {
12.     defer fmt.Println("A.defer")
13.     //匿名函数
14.     func() {
15.     defer fmt.Println("B.defer")
16.     //此时只有defer执行
17.     runtime.Goexit()
18.     fmt.Println("B")
19.     }()
20.     fmt.Println("A")
21.     }()
22.     for {
23.     time.Sleep(time.Second)
24.     }
25.     }

复制代码

• runtime.GOMAXPROCS(): 设置并行计算的CPU核数，返回之前的值
  

1.     package main
3.     import (
4.     "runtime"
5.     "fmt"
6.     )
8.     func main() {
9.     n := runtime.GOMAXPROCS(3)
10.     fmt.Println("n=%d\n",n)
11.     //循环执行2个
12.     for{
13.     go fmt.Print(0)
14.     fmt.Print(1)
15.     }
16.     }

复制代码

channel

• goroutine运行在相同的地址空间,因此访问共享内存必须做好同步，处理好线程安全
  
• goroutine奉行通过通信来共享内存，而不是共享内存通信
  
• channel 是一个引用类型 用于多个goroutine 通讯 其内部实现了同步，确保并发安全
  

Channel  基本使用

<ul>Channel 可以用内置make() 创建
定义一个channel 也需要定义发送到channel值类型
make(chan 类型) // 无缓冲通道
make(chan 类型, 容量) // 有缓冲通道当capacity=0 时， channel 是无缓冲阻塞读写的，当capacity>0, channel 有缓冲，是非阻塞的，直到写满capacity个元素才阻塞写入
channel 通过操作符