本文章开启Golang并发编程。从基础的进程与线程、并行与并发、协程引入和并发并行的区别。再从百万级并发引出并发的安全问题以及解决方案,互斥锁和channel通道,并具体列出代码,同时讲述了channel的循环遍历和关闭。后续内容协程(Goroutine)和管道(Channel)的综合案例(生产者和消费者模式、协程管道定时任务的应用、定时器的终止与重置等)将会在下篇文章中讲出。
目录
前提知识点引入
进程Process与线程Thread
进程定义:进程是并发执行的程序中分配和管理资源的基本单位。
是一个可并发执行的程序在一个数据集上的一次运行。
进程由程序、数据、进程控制块3个基础部分组成
线程定义:线程是进程的执行单元,是进行调度的实体,是比进程更小的独立运行单位。
并行Concurrent与并发Paralle
并行:多个线程同时操作多个资源类(多个cpu)
并发:多线程交替操作同一资源类(相当于cpu)
协程Goroutine的引入
需求:
统计1~2000000的数字中哪些是素数
传统方式:循环判断
优化:使用并发和并行的方式
将统计分配给多个Goroutine去完成
Goroutine 是 Go 语言中并发的执行单位。Goroutine 底层是使用协程 (coroutine) 实现
协程:是单线程下的并发,又称微线程(coroutine)。实现多任务的另外一种方式,只 不过是比线程 更小的执行单元。因为自带cpu的上下文,这样我们只要在合适的时 机,我们就可以把 一个协程切换到另一个协程。
线程和协程的区别
线程的切换是一个cpu在不同线程中来回切换,是从系统层面来,布置保存和恢复cpu上下文那么简单,非常消耗性能。
协程只是在同一个线程内来回切换不同的函数,只是简单的操作cpu的上下文,所以消耗性能会大大减少。
Goland的协程机制,可以轻轻松松开启上万个协程。其他语言并发机制一般基于线程,开启过多资源耗费大。
主线程开启一个Goroutine每隔1s输出 “你好”,在主线程中每隔2s输出 go routine 十次后退出程序,要求主线程和goroutine同时执行
func main() {
go runTimes(10) //main方法执行完了就直接结束,不管其他协程是否执行完
for i := 1; i < 10; i++ {
fmt.Println("main",i,"你好",10-i)
time.Sleep(time.Second*2)
}
}
func runTimes(times int) int {
for i := 1; i < times; i++ {
fmt.Println("runtimes",i,"你好",times-i)
time.Sleep(time.Second)
}
return times
}
1、如果协程没有执行完,但是主线已经结束。协程会直接结束。
2、协程在主线程之前结束。那么协程的任务就完成了
百万级并发
通过上面代码直接更改,以达到百万级的并发,先来看一下会出现什么问题。
var num int = 1
func main() {
for i := 1; i < 10000000; i++ {
go runTimes(1)
}
}
func runTimes(times int) int {
for i := 0; i < times; i++ {
fmt.Println("runtimes",i,"你好",times-i)
fmt.Println("num:",num)
// time.Sleep(time.Second)
}
num++
return times
}
并发的安全问题
var (
testMap = make(map[int]int,10) //只有一个资源,但是有200个协程竞争
)
func testNum (num int) {
res := 1
for i := 1; i <= num; i++ {
res *= i
}
testMap[num] = res
}
func main() {
start := time.Now()
for i := 1; i < 200; i++ {
go testNum(i)
}
//协程需要在main之后完毕
time.Sleep(time.Second*5)
for key,val := range testMap {
fmt.Println("数字%v,对应的阶乘是%v\n",key,val)
}
end := time.Since(start)
fmt.Println(end)
}
直接运行报错:fatal error: concurrent map writes
检测是否存在资源竞争 go build-race main.go 在执行 会提示WARNING: DATA RACE就存在资源竞争。
问题原因:多协程 并发 资源竞争问题
问题的解决方案:
1、互斥锁
全局变量 通过加锁lock unlock 的方法 达到线程安全
Lock sync.Mutex
Lock.Lock() 等待用完 lock.Unlock() //用完一定要解锁!!!!
弊端:因为无法预测到到底要多长时间才能结束,
var (
testMap = make(map[int]int,10)
lock sync.Mutex
)
func testNum (num int) {
lock.Lock()
res := 1
for i := 1; i <= num; i++ {
res *= i
}
testMap[num] = res
lock.Unlock()
}
func main() {
start := time.Now()
for i := 1; i < 20; i++ {
go testNum(i)
}
//协程需要在main之后完毕
// time.Sleep(time.Second*5)
lock.Lock()
for key,val := range testMap {
fmt.Println("数字",key," ,对应的阶乘是",val, "\n")
}
lock.Unlock()
end := time.Since(start)
fmt.Println(end)
}
2、Channel通道
通道本质就是一个数据结构-队列
先进先出FIFO的规则,线程安全,多Goroutine访问不需要加锁,因为通道本身线程安全。
注意:channel是有类型的 定义存放的类型不能放不同类型。当然如果传空接口就能所有类型定义/声明Channel 如:var intchan(别名) chan(关键字) int(类型)
int表示类型 可以是 map[int]string Person *User 等
需要make之后才可以使用 :intchan = make(chan int ,6)
示意图:
<- ->进出 len()长度 cap()容量 //括号里面放别名
代码示例:
var intChan chan int //1、定义
func main() {
intChan = make(chan int, 10) //2、初始化,或者intChan := make(chan int, 10)
intChan <- 1
fmt.Printf("intChan的值是%v,地址是%v\n",<-intChan,intChan)
//<-intChan,(out)取出channel前intchan的len是1,之后len就是0
fmt.Printf("intChan的大小是%v,容积是%v\n",len(intChan),cap(intChan))
strChan := make(chan string,3) //直接初始化
strChan <- "申"
strChan <- "专"
fmt.Printf("strChan的大小是%v,容积是%v\n",len(strChan),cap(strChan))
fmt.Printf("strChan的值是%v,地址是%v\n",<-strChan,strChan)
}
如果1、没有了还往外取2、超出了一开始定义的范围 两种情况就会提示: fatal error: all goroutines are asleep - deadlock!
练习1:
mapChan := make(chan map[int]string,5)
map1 := make(map[int]string,2)
map1[0] = "申"
map1[1] = "专"
mapChan <- map1
map2 := make(map[int]string,2)
map2[0] = "请"
map2[1] = "利"
mapChan <- map2
fmt.Printf("%v \t %v \n",<-mapChan,<-mapChan)
练习2:
空类型的接口放什么都可以 chan interface{}
allChan := make(chan interface{},5) //chan interface{}空接口放什么都可以
allChan <- dog{Name: "小黄",Color: "yellow"}
allChan <- 1
allChan <- "小黄很可爱"
// fmt.Printf("%v\t%v\t%v\n",<-allChan,<-allChan,<-allChan)
// dog1 := <-allChan
// fmt.Printf("%T \n",dog1)
// fmt.Printf("%T \n",dog.Color) //看到dog但是拿不到他的任何属性和方法
// a := dog1.(dog) //需要类型断言,才可以拿到他的值的方法
a := (<-allChan).(dog) //与上面等价
fmt.Println(a.Color)
Channel的循环遍历与关闭
For-range循环取值需要close(chanName)
否则报错:fatal error: all goroutines are asleep - deadlock!
close(allChan) //管道关闭后不能再写入
for val := range allChan {
fmt.Println(val)
}
//注意如果用下面这个每一次取出len都在变化,最后不能完全取出
for i := 0;i < len(allChan); i++ {
fmt.printf(<-allChan)
}
for {
val,ok := <-allChan
If !ok {
break
}
Fmt.println(val)
}