Golang并发编程学习笔记（一）

最新推荐文章于 2023-04-23 14:38:15 发布

怜雨慕

最新推荐文章于 2023-04-23 14:38:15 发布

阅读量209

点赞数 2

分类专栏： Golang并发学习文章标签： golang

本文链接：https://blog.csdn.net/weixin_54083160/article/details/129064555

版权

Golang并发学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文章开启Golang并发编程。从基础的进程与线程、并行与并发、协程引入和并发并行的区别。再从百万级并发引出并发的安全问题以及解决方案，互斥锁和channel通道，并具体列出代码，同时讲述了channel的循环遍历和关闭。后续内容协程(Goroutine)和管道(Channel)的综合案例（生产者和消费者模式、协程管道定时任务的应用、定时器的终止与重置等）将会在下篇文章中讲出。

前提知识点引入

进程Process与线程Thread

并行Concurrent与并发Paralle

前提知识点引入

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

怜雨慕

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Golang并发编程学习笔记（一）

本文章开启Golang并发编程。从基础的进程与线程、并行与并发、协程引入和并发并行的区别。再从百万级并发引出并发的安全问题以及解决方案，互斥锁和channel通道，并具体列出代码，同时讲述了channel的循环遍历和关闭。后续内容协程(Goroutine)和管道(Channel)的综合案例（生产者和消费者模式、协程管道定时任务的应用、定时器的终止与重置等）将会在下篇文章中讲出。
复制链接

扫一扫

专栏目录