Golang并发编程学习笔记（一）
本文章开启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)
} 
