[golang]golang并发编程-协程

已于 2022-04-04 19:22:54 修改
阅读量666 收藏
点赞数
分类专栏： Golang 文章标签： golang web
于 2022-04-03 22:07:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43566459/article/details/123945579
版权

协程，也叫gorountine
go 语言诞生比较晚，web2.0开发逐渐主流，高并发需求大
go 一开始就没有打算让我们去实例化一个线程，而是使用协程

多线程 - 每个线程占用的内存比较多 而且系统切换开销比较大
轻量化线程 -> 协程，是用户级别的
python中有两种编程模式 1.多线程和多进程进行并发编程 2.使用协程进行并发编程

1.goruntine

func p(){
	fmt.Println("bobby")
}
func main(){
	go p()
}

上述代码就是简单的协程
执行结果：什么都没有
原因：主协程先关闭，主死从随

func p(){
	fmt.Println("bobby")
}
func main(){ //主协程  
	//主死从随
	go p()
	time.Sleep(time.Second*2)
}

打印结果：bobby

也可以使用匿名函数

func main(){ //主协程  
	//主死从随
	for i:=0;i < 5;i++{
		go func(){
			fmt.Println(i)
		}
	}
	time.Sleep(time.Second*2)
}

打印结果：5 5 5 5 5

func main(){ //主协程  
	//主死从随
	for i:=0;i < 5;i++{
		//闭包
		go func(){
			fmt.Println(i)
			time.Sleep(time.Second)
		}
	}
	time.Sleep(time.Second*2)
}

打印结果：1 2 3 4 5

一直用time.Sleep去维持主协程肯定不是个事，因此我们来使用WaitGroup：

2.WaitGroup

WaitGroup通了三个很有用的函数：
Add()
Done()
Wait()

var wg sync.WaitGroup
func f(n int){
	defer wg.Done()
	fmt.Println(n)
}
func main(){
	for i := 0; i < 5; i++{
		wg.Add(1)
		go f(i)
	}
	wg.Wait()
}

3.互斥锁


var total int
var wg sync.WaitGroup
func add(){
	defer wg.Done()
	for i := 0; i < 5; i++{
		total = total+1
	}
}
func sub(){
	defer wg.Done()
	for i := 0; i < 5; i++{
		total = total-1
	}
}
func main(){
	wg.Add(2)
	
	go add()
	go sub()
	
	wg.Wait()
	fmt.Println(total)
}

理论结果：0
实际结果：不是0，随机-5~5，每次结果不一样

total = total+1

这个代码：
1.从total取出值
2.将total+1
3.将total+1的计算结果放回total中


var total int
var wg sync.WaitGroup
var lock sync.Mutex
func add(){
	defer wg.Done()
	for i := 0; i < 5; i++{
		lock.Lock()
		total = total+1
		lock.Unlock
	}
}
func sub(){
	defer wg.Done()
	for i := 0; i < 5; i++{
		lock.Lock()
		total = total-1
		lock.Unlock
	}
}
func main(){
	wg.Add(2)
	
	go add()
	go sub()
	
	wg.Wait()
	fmt.Println(total)
}

运行结果：0

4. 读写锁

互斥锁性能太差
绝大多数web系统都是读多写少


var total int
var wg sync.WaitGroup
var rwlock sync.RWMutex
func read(){
	defer wg.Done()
	rwlock.RLock()
	fmt.Println("开始读取数据")
	time.Sleep(time.Second*10)
	fmt.Println("读取成功")
	rwLock.RUlock()

}
func write(){
	defer wg.Done()
	rwlock.WLock()
	fmt.Println("开始修改数据")
	time.Sleep(time.Second*10)
	fmt.Println("修改成功")
	rwLock.WUlock()
}
func main(){
	wg.Add(1)
	for i := 0; i < 5; i++{
		wg.Add(1)
		go read()
	}
	go write()
	wg.Wait()
	fmt.Println(total)
}

读取之间互不影响，写锁进来都停止

5. channel

channel提供了一种通信机制，类似java的消息队列
关键字chan

func main(){
	//1.定义一个channel
	var msg chan int
	//2.初始化这个channel，两种方式
	msg = make(chan int) //第一种初始化方式;无缓冲
	//msg = make(chan int，1) //第二种初始化方式;有缓冲
	//在go语言中使用make初始化的有三种：1.slice 2.map 3.chan
	msg <- 1 //将1 放入channel中
	data := <- msg  //将箭头右边的值放到左边
	fmt.Println(data)
}

运行结果：失败 deadlock
原因：无缓冲空间

func main(){
	//1.定义一个channel
	var msg chan int
	//2.初始化这个channel，两种方式
	//msg = make(chan int) //第一种初始化方式;无缓冲
	msg = make(chan int，1) //第二种初始化方式;有缓冲
	//在go语言中使用make初始化的有三种：1.slice 2.map 3.chan
	msg <- 1 //将1 放入channel中
	//msg <- 2 //再放就会报错，超出缓冲大小
	data := <- msg  //将箭头右边的值放到左边
	fmt.Println(data) 
}

运行结果：1


var wg sync.WaitGroup
func consumer (queue chan int) {
	defer wg.Done()
	data := <-queue 
	fmt.Println(data)
}
func main(){
	//1.定义一个channel
	var msg chan int
	//2.初始化这个channel，两种方式
	//msg = make(chan int) //第一种初始化方式;无缓冲
	msg = make(chan int，1) //第二种初始化方式;有缓冲
	//在go语言中使用make初始化的有三种：1.slice 2.map 3.chan
	msg <- 1 //将1 放入channel中
	wg.Add(1)
	go consumer(msg)
	msg <- 2
	wg.Wait()
	
}

6. 遍历channel和关闭channel


var wg sync.WaitGroup
func consumer (queue chan int) {
	defer wg.Done()
	for data := range queue{
		fmt.Println(data)
		time.Sleep(time.Second)
	}
	
}
func main(){
	//1.定义一个channel
	var msg chan int
	//2.初始化这个channel，两种方式
	//msg = make(chan int) //第一种初始化方式;无缓冲
	msg = make(chan int，1) //第二种初始化方式;有缓冲
	//在go语言中使用make初始化的有三种：1.slice 2.map 3.chan
	msg <- 1 //将1 放入channel中
	wg.Add(1)
	go consumer(msg)
	msg <- 2
	//关闭channel  1.已经关闭的channel不能再发送数据了 
	// 2.已经关闭的channel消费者可以继续取出数据
	close(msg)
	wg.Wait()
	
}

结果：
1
2


var wg sync.WaitGroup
func consumer (queue chan int) {
	defer wg.Done()
	for {
		data := <-queue 
		fmt.Println(data)
		time.Sleep(time.Second)
	}
	
}
func main(){
	//1.定义一个channel
	var msg chan int
	//2.初始化这个channel，两种方式
	//msg = make(chan int) //第一种初始化方式;无缓冲
	msg = make(chan int，1) //第二种初始化方式;有缓冲
	//在go语言中使用make初始化的有三种：1.slice 2.map 3.chan
	msg <- 1 //将1 放入channel中
	wg.Add(1)
	go consumer(msg)
	msg <- 2
	//关闭channel  1.已经关闭的channel不能再发送数据了 
	// 2.已经关闭的channel消费者可以继续取出数据
	close(msg)
	wg.Wait()
	
}

结果：
1
2
0
0
0
0
…

chan取出的值有两个返回值，第二个是ok

var wg sync.WaitGroup
func consumer (queue chan int) {
	defer wg.Done()
	for {
		data,ok := <-queue 
		fmt.Println(data，ok)
		time.Sleep(time.Second)
	}
	
}
func main(){
	//1.定义一个channel
	var msg chan int
	//2.初始化这个channel，两种方式
	//msg = make(chan int) //第一种初始化方式;无缓冲
	msg = make(chan int，1) //第二种初始化方式;有缓冲
	//在go语言中使用make初始化的有三种：1.slice 2.map 3.chan
	msg <- 1 //将1 放入channel中
	wg.Add(1)
	go consumer(msg)
	msg <- 2
	//关闭channel  1.已经关闭的channel不能再发送数据了 
	// 2.已经关闭的channel消费者可以继续取出数据
	close(msg)
	wg.Wait()
	
}

结果：
1 true
2 true
0 false
0 false
0 false
0 false
…

使用ok判读break时机


var wg sync.WaitGroup
func consumer (queue chan int) {
	defer wg.Done()
	for {
		data,ok := <-queue 
		if !ok{
			break
		}
		fmt.Println(data)
		time.Sleep(time.Second)
	}
	
}
func main(){
	//1.定义一个channel
	var msg chan int
	//2.初始化这个channel，两种方式
	//msg = make(chan int) //第一种初始化方式;无缓冲
	msg = make(chan int，1) //第二种初始化方式;有缓冲
	//在go语言中使用make初始化的有三种：1.slice 2.map 3.chan
	msg <- 1 //将1 放入channel中
	wg.Add(1)
	go consumer(msg)
	msg <- 2
	//关闭channel  1.已经关闭的channel不能再发送数据了 
	// 2.已经关闭的channel消费者可以继续取出数据
	close(msg)
	wg.Wait()
	
}

结果：
1
2

7.双向和单向channel

//无缓冲


var wg sync.WaitGroup
func consumer (queue chan int) {
	defer wg.Done()
	for {
		data,ok := <-queue 
		if !ok{
			break
		}
		fmt.Println(data)
		time.Sleep(time.Second)
	}
	
}
func main(){
	//1.定义一个channel
	var msg chan int
	//2.初始化这个channel，两种方式
	msg = make(chan int) //第一种初始化方式;无缓冲
	//在go语言中使用make初始化的有三种：1.slice 2.map 3.chan
	wg.Add(1)
	go consumer(msg)//无缓冲，先启动消费
	msg <- 1 //将1 放入channel中
	//msg <- 2
	//关闭channel  1.已经关闭的channel不能再发送数据了 
	// 2.已经关闭的channel消费者可以继续取出数据
	 close(msg)
	wg.Wait()
	
}

//单、双向


var wg sync.WaitGroup
func consumer (queue <-chan int) { //只能取值。单向
	defer wg.Done()
	for {
		data,ok := <-queue 
		if !ok{
			break
		}
		fmt.Println(data)
		time.Sleep(time.Second)=
	}
	
}
func main(){
 	var msg chan int //双向
	//var msg chan<- int //单向
	msg = make(chan int) 
	wg.Add(1)
	go consumer(msg)//普通的channel可以直接转换成单向的
	msg <- 1 //将1 放入channel中
	 close(msg)
	wg.Wait()
	
}


var wg sync.WaitGroup
func consumer (queue <-chan int) { //只能取值。单向
	defer wg.Done()
	for {
		data,ok := <-queue 
		if !ok{
			break
		}
		fmt.Println(data)
		time.Sleep(time.Second)=
	}
	
}
func stock(queue chan<- int{
	defer wg.Done
	for{
		queue <- 1
		time.Sleep(time.Second)
	}
}
func main(){
 	var msg chan int //双向
	//var msg chan<- int //单向
	msg = make(chan int) 
	wg.Add(1)
	go consumer(msg)//普通的channel可以直接转换成单向的
	msg <- 1 //将1 放入channel中
	 close(msg)
	wg.Wait()
	
}

deadlock出现场景

1.无缓冲直接放值，且没有一个goruntine去消费
2.channel是多个goruntine之间线程安全：1.获取锁，2.等到消费者消费，3.释放锁

anyTimeWithYou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang并发编程的实现
12-23
main函数的执行本身就是一个协程，当使用go关键字的时候，就会创建一个新的协程 channel channel 管道，用于在多个协程之间传递信号 无缓存管道 当对无缓冲通道写的时候，会一直阻塞等到某个协程对这个缓冲通道读 ...
Golang 并发编程指南
j简说Linux的博客
11-09 771
简单调度图如上，有关于 P 再多个 M 中切换，公共 goroutine 队列，M 从线程缓存中创建等步骤没有体现，复杂过程可以参考文章简单了解。我们可以再每个 CPU 上进行循环无关的迭代计算，我们仅需要创建完所有的 goroutine 后，从 channel 中读取结束信号进行计数即可。这东西可以并发读，不可以并发读写/并发写写，不过现在即便场景是读多写少也很少用到这，一般集群环境都得分布式锁了。关系如图，灰色的 G 则是暂时还未运行的，处于就绪态，等待被调度，这个队列被 P 维护。
Golang并发模型：并发协程的优雅退出
foreverm99的博客
12-15 1306
goroutine的退出机制，不能通过某种手段强制关闭，只能等goroutine主动退出。 常用三种方式： 一、 通道有 chan, for range、 for select for-range， 当无缓存通道关闭时，for-range 自动退出。 需要close(chan) ， 否则会死锁。 使用 select ok 退出 for-select也是使用频率很高的结构，select提供了多路复用的能力，所以for-select可以让函数具有持续多路处理多个c...
golang并发编程之协程
ManNiaoQinFen的博客
06-17 250
Golang 中的并发是**函数**相互独立运行的能力。**Goroutines** 是并发运行的函数。Golang 提供了 Goroutines 作为并发处理操作的一种方式。
Golang亿级高并发实例（代码可直接使用）
lys07962000的专栏
04-20 2482
main.go package main import ( "fmt" conc "github.com/micro/examples/Test/Concurrence" "runtime" //"runtime" "time" ) //定义一个实现Job接口的数据 type Score struct { Num int } //定义对数据的处理 fu...
使用Go语言实现高效的并发编程
Code Metaverse
12-15 1376
Go语言支持并发编程。你可以通过创建多个并发单元（称为goroutines）来实现多线程编程。每个goroutine都是一个独立的执行单元，可以并行执行代码。这样，两个函数就会同时执行，可以大大提高程序的效率。Go语言提供了一些内置的通信机制（例如信道）来协调多个goroutine之间的交互。这个特性可以帮助我们编写高效的并发程序，可以充分利用多核处理器的优势，提高程序的性能。
使用golang进行高性能编码-Golang开发
05-26
第三章 并发编程 读写锁和互斥锁的性能比较 如何退出协程(超时场景) 第四章 编译优化 减小编译体积 附录 Go 语言陷阱 数组和切片 基础入门 Go 语言简明教程 Go Test 单元测试简明教程 Go Protobuf ...
基于Golang协程实现流量统计系统视频.zip
06-22
2-2 并发编程--协程 2-3 Golang协程基本示例 第3章 Go的协程 3-1 Golang协程特性实践 3-2 golang select多队列选择器 3-3 selete等待机制 第4章 示例环境搭建 4-1 快速构建一个示例网站（上） 4-2 快速构建一个示例...
golang 40行代码实现通用协程池
09-20
golang协程机制很方便的解决了并发编程的问题，但是协程并不是没有开销的，所以也需要适当限制一下数量。这篇文章主要介绍了golang 40行代码实现通用协程池,需要的朋友可以参考下
深入解析Go语言并发编程中的协程机制与应用场景
最新发布
04-25
深入解析Go语言并发编程中的协程机制与应用场景
如何利用Golang写出高并发代码详解
01-01
前言 之前一直对Golang如何处理高并发http请求的一头雾水,这几天也查了很多相关博客,似懂非懂,不知道具体代码怎么写 下午偶然在开发者头条APP上看到一篇国外技术人员的一篇文章用Golang处理每分钟百万级请求,看完文章中的代码,自己写了一遍代码,下面自己写下自己的体会 核心要点 将请求放入队列,通过一定数量(例如CPU核心数)goroutine组成一个worker池(pool),workder池中的worker读取队列执行任务 实例代码 以下代码笔者根据自己的理解进行了简化,主要是表达出个人的思路,实际后端开发中,根据实际场景修改 func doTask() { //耗时炒作(
golang学习（1）
DETACH-MENT的博客
10-11 386
Go语言字符串底层数据也是对应的字节数组，但是字符串的只读属性禁止了在程序中对底层字节数组的元素的修改。字符串赋值只是复制了数据地址和对应的长度，而不会导致底层数据的复制。 每个字符串的长度虽然也是固定的，但是字符串的长度并不是字符串类型的一部分。 字符串结构由两个信息组成：第一个是字符串指向的底层字节数组，第二个是字符串的字节的长度。字符串其实是一个结构体，因此字符串的赋值操作也就是reflect.StringHeader结构体的复制过程，并不会涉及底层字节数组的复制。 切片 切片的行为更为灵活，
golang协程
qq_41078889的博客
02-15 3116
协程（coroutine）是Go语言中的轻量级线程实现，由Go运行时（runtime）管理。 在一个函数调用前加上go关键字，这次调用就会在一个新的goroutine中并发执行。当被调用的函数返回时，这个goroutine也自动结束。需要注意的是，如果这个函数有返回值，那么这个返回值会被丢弃。 func longWait() { fmt.Println("Beginning longWait()") time.Sleep(5 * 1e9) fmt.Println("End of longWait
Go 并发 -- 协程
weixin_33843409的博客
04-18 211
这是『就要学习 Go 语言』系列的第 21 篇分享文章 并发与并行 提到并发，相信大家还听过另一个概念 -- 并行。我先给大家介绍下这两者之间的区别，再来讲 Go 语言的并发。 并行其实很好理解，就是同时执行的意思，在某一时间点能够执行多个任务。 想达到并行效果，最简单的方式就是借助多线程或多进程，这样才可在同一时刻执行多个任务。单线程是永远无法达到并行状态的。 并发是在某一时间段内可以同时处...
Goroutine协程调度
qq_43756091的博客
06-12 321
笔者之前是做Java开发的，在Java中如果要进行并发编程通常需要维护一个线程池。线程池的目的是减少频繁创建线程造成的不必要的开销。线程池中预先保存一定数量的线程，而新任务将不再以创建线程的方式去执行，而是将任务发布到任务队列，线程池中的线程不断地从任务队列中取出任务并执行，可以有效的减少线程创建和销毁所带来的开销。 G代表任务，往往代表一个函数。 线程池中的worker线程不断地从任务队列中取出任务并执行。而worker线程的调度则交给操作系统进行调度。 让我思考以下2个问题 如果worker线程执行
Golang_13: Go语言 并发编程：协程(goroutine)、通道(chan)、同步锁(Mutex)、WaitGroup、上下文(context)
谢TS的博客
05-26 686
Go 语言的并发编程使用 协程（goroutine）实现。Go 语言的每一个并发执行的任务称为 goroutine，也包括执行 main() 函数的任务。Go 启动一个 goroutine 非常简单，在任何函数或方法调用前面加上 go 关键字，该函数或方法的调用即异步执行。
golang 并发控制代码
m0_46426259的博客
02-07 196
package main import ( "fmt" "time" ) type GoPool struct { MaxLimit int tokenChan chan struct{} } type GoPoolOption func(*GoPool) func WithMaxLimit(max int) GoPoolOption { return func(gp *GoPool){ gp.MaxLimit = max gp.tokenChan = make(chan stru
Golang知识点四、并发编程
菜到不敢run
04-16 1390
Golang中的锁   Golang并发通过goroutine来实现。goroutine是由Go语言的运行时（runtime）调度完成的，而线程是由操作系统调度完成。goroutine和channel是Go秉承的CSP(Communicating Sequential Process)并发模式的重要实现基础。 1. 竞态   竞态是指在多个goroutine按某些交错顺序执行时，程序无法给出正确的结果。它对于程序是致命的，因为它们潜伏在程序中，出现的频率也很低，有可能仅在高负载环境或者在特定的编译器、平
Go 协程并发编程
wwxy1995的博客
07-07 131
在Go语言中，实现并发编程是特别容易的 使用关键词go package main import ( "fmt" "time" ) func main() { go CountNumber() // 携程并行 for i := 1; i <= 10; i++ { fmt.Println(i) time.Sleep(1 * time.Second) } fmt.Pr...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值