Golang 进阶3—— 协程&管道

于 2024-10-06 16:45:54 发布
阅读量540 收藏 3
点赞数 20
文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41835324/article/details/142728894
版权

Golang 进阶3—— 协程&管道

注意，该文档只适合有编程基础的同学，这里的go教程只给出有区别的知识点

注意 程序 & 进程 & 协程 的区别

1. 协程

又称为微线程， 纤程， 协程是一种用户态的轻量级线程

作用： 在执行 A 函数的时候， 可以随时中断， 去执行B函数，然后中断继续执行A函数（可以自由切换）， 注意这一切换并不是函数调用（没有调用语句）， 过程很像多线程，然而协程中只有一个线程在执行 （协程的本质是个单线程）。线程是CPU控制的，而协程是程序自身控制的，属于程序级别的切换，操作系统完全感知不到，从而更加轻量级。

对于单线程下， 我们不可避免程序中出现IO 操作，但如果我们能在自己的程序中（即用户程序级别，而非操作系统级别）控制单线程下的多个任务能在一个任务遇到IO阻塞时就将寄存器上下文和栈保存到某个地方，然后切换到另外一个任务去计算。在任务切换回来的时候，恢复先前保存的寄存器上下文和栈，这样就保证该线程能够最大限度处于就绪态，即随时都可以被CPU执行的状态，相当于我们在用户级别将自己的IO操作最大限度隐藏起来，从而可以迷惑操作系统，让其看到：该线程好像是一直在计算，IO比较少，从而会更多的将cpu的执行权限分配给我们线程。

1.1 main文件
import (
	"fmt"
	"time"
	"strconv"
)

func test () {
	for i := 1; i <= 10; i++ {
		fmt.Println("test, golang", strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}
func main() {// 主线程
	go test() // 启动一个协程, 在语句前面加上 go
	for i := 1; i <= 9; i++ {
		fmt.Println("main, golang", strconv.Itoa(i))
		// 阻塞 1 秒
		time.Sleep(time.Second)
	}
}
1.2 输出结果
(base) PS E:\Goproject\src\gocode\testproject01> go run .\main\main.go
main, golang 1
test, golang 1
test, golang 2
main, golang 2
main, golang 3
test, golang 3
test, golang 4
main, golang 4
main, golang 5
test, golang 5
test, golang 6
main, golang 6
main, golang 7
test, golang 7
test, golang 8
main, golang 8
main, golang 9
test, golang 9
// 从结果可以看出，当主线程死掉之后，协程会直接死掉，不会继续执行。（本来还要继续输出： test, golang 10）—— 主死从随


// 不加 go 的情况
(base) PS E:\Goproject\src\gocode\testproject01> go run .\main\main.go
test, golang 1
test, golang 2
test, golang 3
test, golang 4
test, golang 5
test, golang 6
test, golang 7
test, golang 8
test, golang 9
test, golang 10
main, golang 1
main, golang 2
main, golang 3
main, golang 4
main, golang 5
main, golang 6
main, golang 7
main, golang 8
main, golang 9
1.3 启动多个协程
import (
	"fmt"
	"time"
)

func main() {// 主线程
	for i := 0; i < 10; i++ {
		go func (i int) {
			fmt.Println(i)
		}(i)
	}
	time.Sleep(time.Second * 2)
}
1.4 输出结果
(base) PS E:\Goproject\src\gocode\testproject01> go run .\main\main.go
0
1
9
5
6
3
7
4
8
2
2. WaitGroup

WaitGroup 用于等待一组线程结束的结束。 父线程调用 Add 方法来设定应等待的线程的数量。每个被等待的线程在结束时应调用Done方法。同时，主线程里可以调用Wait方法阻塞至所有线程结束。 ——> 解决主线程在子协程结束之后自动结束。（详细可以查看api中的sync 包）

2.1 main文件
import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup
func main() {// 主线程

	// 启动 5 个协程
	for i := 0; i < 5; i++ {
		wg.Add(1) // 计数器加一
		go func (i int) {
			fmt.Println(i)
			defer wg.Done() // 协程执行完毕，计数器减一
		}(i)
	}
	wg.Wait() // 等待协程执行结束， 当计数器达到 0 的时候才结束
}
2.2 输出结果
(base) PS E:\Goproject\src\gocode\testproject01> go run .\main\main.go
0
1
3
4
2
2.3 多线程对同一个数进行操作 —— 要加锁 (互斥锁)
// 竞争条件：sum 变量被多个 goroutine 并发访问，而没有适当的同步机制（如互斥锁）。这会导致数据的竞争条件，使得 sum 的值可能计算不正确。
package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup
var mu sync.Mutex // 互斥锁
var sum int 
func add () {
	for i := 0; i < 1000000; i++ {
		wg.Add(1)
		go func (i int) {
			mu.Lock() // 加锁
			sum += i
			mu.Unlock() // 解锁
			defer wg.Done()
		}(i)
	}
}


func sub () {
	for i := 0; i < 1000000; i++ {
		wg.Add(1)
		go func (i int) {
			mu.Lock() // 加锁
			sum -= i
			mu.Unlock() // 解锁
			defer wg.Done()
		}(i)
	}
}
func main() {// 主线程
	add()
	sub()
	wg.Wait() // 等待协程执行结束， 当计数器达到 0 的时候才结束
	fmt.Println(sum)
}
2.4 输出结果
(base) PS E:\Goproject\src\gocode\testproject01> go run .\main\main.go
0
2.5 另外一种锁

RWMutex是一种读写锁， 其经常用于读的次数远远多于写次数的场合—— 在读的时候，数据之间不产生影响，写和读之间才会产生影响

package main

import (
	"fmt"
	"sync"
	"time"
)

var wg sync.WaitGroup
var lock sync.RWMutex // 读写锁

func read () {
	wg.Add(1)
	defer wg.Done()
	lock.RLock() // 读锁
	fmt.Println("read")
	time.Sleep(time.Second)
	lock.RUnlock() // 解锁
}

func write () { 
	wg.Add(1)
	defer wg.Done()
	lock.Lock() // 写锁
	fmt.Println("write")
	time.Sleep(time.Second * 3)
	fmt.Println("write over")
	defer lock.Unlock() // 解锁
	
}
func main() {// 主线程
	for i := 0; i < 10; i++ {
		go read()
	}
	go write()
	wg.Wait() // 等待协程执行结束， 当计数器达到 0 的时候才结束
}
2.6 输出结果
(base) PS E:\Goproject\src\gocode\testproject01> go run .\main\main.go
read
read
write
write over
read
read
read
read
read
read
read
read
3. 管道

管道的本质就是一个数据结构——队列（先进先出）。 自身线程安全，不需要加锁，channel本身就是线程安全的,多个协程操作同一个管道时候，不会发生资源争抢问题。管道有类型，一个string的管道只能存放string类型的数据。

3.1 main文件
import (
	"fmt"
)

/*管道
	chan管道关键字
	数据类型是指管道的类型，里面放入数据的类型， 管道是有类型的， int类型的管道只能写入int
	管道是引用类型，必须初始化才能写入数据，即make之后才能使用
*/
func main() { // 主线程
	// 定义管道
	var inChan chan int
	// 通过make初始化， 管道可以存放3个int类型的变量
	inChan = make(chan int, 3)
	// 证明是引用类型
	fmt.Println(inChan) // 输出管道地址

	// 存放数据
	inChan <- 1
	inChan <- 2
	inChan <- 3

	// 超过定义的长度，会报错 fatal error: all goroutines are asleep - deadlock!
	// inChan <- 4
	fmt.Println("管道的长度：", len(inChan))

	// 取数据
	num1 := <-inChan
	fmt.Println(num1)

	num2 := <-inChan
	fmt.Println(num2)

	num3 := <-inChan
	fmt.Println(num3)

	// 关闭管道， 关闭之后，还可以读数据，但是写不了数据了
	close(inChan)

	fmt.Println("--------------------------------------------------")

	// 管道遍历
	for v := range inChan { // 没有索引
		fmt.Println("value = ", v)
	}

	// 重新初始化管道
	inChan = make(chan int, 3)
	inChan <- 4
	inChan <- 5
	inChan <- 6

	close(inChan)
	// 管道遍历 在遍历前如果没有加入 close(inChan) 会报错， fatal error: all goroutines are asleep - deadlock!
	// 所以在遍历前要把管道关闭
	for v := range inChan { // 没有索引
		fmt.Println("value = ", v)
	}

}
3.2 输出结果
(base) PS E:\Goproject\src\gocode\testproject01> go run .\main\main.go
0xc000080100
管道的长度： 3
1
2
3
--------------------------------------------------
value =  4
value =  5
value =  6
3.3 协程 + 管道
import (
	"fmt"
	"time"
	"sync"
)

var wg sync.WaitGroup

// 写入数据
func writeFunc (ch chan int) {
	defer wg.Done()
	for i := 1; i <= 50; i++ {
		fmt.Println("write:", i)
		ch <- i
		time.Sleep(time.Second)
	}
	close(ch)
}

// 读数据
 func readFunc (ch chan int) {
	defer wg.Done()
	for n := range ch {
		fmt.Println("read data:", n)
		time.Sleep(time.Second)
	}
}


func main() { // 主线程
	fmt.Println("rw")
	wg.Add(2)
	ch := make(chan int, 50) // 创建管道，容量为50
	go writeFunc(ch)
	go readFunc(ch)
	wg.Wait()	
}
3.4 输出结果
(base) PS E:\Goproject\src\gocode\testproject01> go run .\main\main.go
rw
write: 1
read data: 1
write: 2
read data: 2
write: 3
read data: 3
write: 4
read data: 4
write: 5
read data: 5
write: 6
read data: 6
write: 7
read data: 7
...
3.5 声明只读只写管道
func main() { // 主线程
	//ch := make(chan int, 10) // 默认情况下，管道可读可写

	// 声明只写
	// ch2 := make(chan<- int, 10)
	// ch2 <- 1
	// num1 := <-ch2
	// fmt.Println(num1) // invalid operation: cannot receive from send-only channel ch2 (variable of type chan<- int)

	// 声明只读
	ch3 := make(chan int, 10)
	ch3 <- 1
	ch3 <- 2
	close(ch3)

	if ch3 == nil {
		fmt.Println("ch3 is nil")
	} else {
		num2 := <-ch3
		fmt.Println(num2)
	}

}
3.6 输出结果
(base) PS E:\Goproject\src\gocode\testproject01> go run .\main\main.go
1
3.7 管道阻塞

当管道只写入数据，没有读出数据就会进入阻塞状态

var wg sync.WaitGroup
func main() { // 主线程
	ch := make(chan int, 10) // 默认情况下，管道可读可写

	//  值写入不读 fatal error: all goroutines are asleep - deadlock!
	for i := 1; i <= 10; i++ {
		wg.Add(1)
		defer wg.Done()
		go func(i int) {
			ch <- i
		}(i)
		
	}
	wg.Wait()
	fmt.Println("over")
}
3.8 输出结果
(base) PS E:\Goproject\src\gocode\testproject01> go run .\main\main.go
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [semacquire]:
sync.runtime_Semacquire(0xc000008108?)
        D:/Go/src/runtime/sema.go:71 +0x25
sync.(*WaitGroup).Wait(0xc0000281c0?)
        D:/Go/src/sync/waitgroup.go:118 +0x48
main.main()
        E:/Goproject/src/gocode/testproject01/main/main.go:20 +0x12e
exit status 2
4. select

功能： 解决多个管道的选择问题， 也可以叫做多路复用，可以从多个管道中随机公平地选择一个来执行；

case后面必须进行的是IO操作，不能是等值，随机去选择一个IO执行

default 防止select被阻塞， 加入default

4.1 main
import (
	"fmt"
	"time"
)


func main() { // 主线程
	intCh := make(chan int, 10) 
	stringCh := make(chan string, 10)

	go func () {
		time.Sleep(time.Second * 2)
		intCh <- 1
	}()

	go func () {
		time.Sleep(time.Second * 3)
		stringCh <- "hello"
	}()

	select {
		case data := <-intCh:
			fmt.Println("intChan :", data)
		case data := <-stringCh:
			fmt.Println("stringChan :", data)
		default:
        	fmt.Println("防止select被阻塞")
	}

}
4.2 输出结果
(base) PS E:\Goproject\src\gocode\testproject01> go run .\main\main.go
防止select被阻塞
5. refer + recover 解决错误
5.1 main
import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup
// 输出操作
func printNum () {
	defer wg.Done()
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}
}


// 除法操作
func devide () {
	defer wg.Done()
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("程序异常： ", err)
		}
	}()
	num1 := 10
	num2 := 0
	res := num1 / num2
	fmt.Println("结果： ", res)
}

func main() { // 主线程
	wg.Add(2)
	go printNum()
	go devide()
	wg.Wait()

}
5.2 输出结果
(base) PS E:\Goproject\src\gocode\testproject01> go run .\main\main.go
程序异常：  runtime error: integer divide by zero
0
1
2
3
4
5
6
7
8
9
小吴同学（wlx）
关注
golang学习笔记（进阶篇）
lcynone的博客
01-13 743
Golang学习笔记_进阶篇
golang开发技巧
yonggeit的博客
01-17 3281
使用gofmt 重要的话说3遍 使用gofmt 使用gofmt 使用gofmt gofmt是golang提供的代码格式化工具，整个团队使用，就不需要做代码风格审查了 协程使用规范 将并发留给调用者 // ListDirectory returns the contents of dir. func ListDirectory(dir string) ([]string, error) // Li...
Golang 学习（二）进阶使用
qq_42767993的博客
02-06 1381
P代表着处理器(processor)，它的主要用途就是用来执行goroutine的，一个P代表执行一个go代码片段的基础(上下文环境)，所以它也维护了一个可运行的goroutine队列，和自由的goroutine队列，里面存储了所有需要它来执行的goroutine。Seched代表着一个调度器，它维护有存储空闲的M队列和空闲的P队列，可运行的G队列，自由的G队列（全局runqueue）以及调度器的一些状态信息等。中，本地运行队列中的 goroutine 会一直等待直到自己被分配的逻辑处理器执行。
Golang入门——channel的进阶使用
qq_23680847的博客
10-31 213
Golang入门——channel的进阶使用单向管道关闭管道有缓冲区管道与无缓冲区管道的区别 单向管道 顾名思义，单向管道就是只能用于发送或者接收数据。从管道的数据结构上看，并没有单向的管道。所谓的单向管道就是对管道的一种限制。 func readChannel(ChanName <-chan int){ ... } func writeChannel(ChanName chan<- int){ ... } 其中 <-chan 和 chan <- 均为单向管道。如果向读管道写入数据
Go语言入门学习--进阶篇协程
tamako0v0的博客
07-23 307
一．进程 线程 协程 1.1进程 线程 协程分别是什么 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。每个进程都有自己的独立内存空间，拥有自己独立的堆和栈，既不共享堆，亦不共享栈，进程由操作系统调度。不同进程通过进程间通信来通信。由于进程比较重量，占据独立的内存，所以上下文进程间的切换开销（栈、寄存器、虚拟内存、文件句柄等）比较大，但相对比较稳定安全。 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立...
Golang Devops项目开发
niwoxiangyu的博客
07-27 1910
通过go help test可以看到go test的使用说明：格式形如：参数解读：-c : 编译go test成为可执行的二进制文件，但是不运行测试。-i : 安装测试包依赖的package，但是不运行测试。关于build flags，调用go help build，这些是编译运行过程中需要使用到的参数，一般设置为空关于packages，调用go help packages，这些是关于包的管理，一般设置为空。
104.【GoLang基础】
qq_69683957的博客
03-21 648
变量: 就是变化的量package main // 这里的包一定要写成 main. import "fmt" // 导入包 func main() {// 主函数 // 如果想要同时定义多个不同类型的变量有两种方式。
Learn Golang
weixin_30932215的博客
05-19 711
学习 Go 语言 官方文档 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Hello World . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 ...
PHP进阶面试题
颜夕_
06-11 2921
比较一下php和go的区别？ Go是一种静态类型语言。PHP是一种动态类型语言。 PHP 每个请求进来时都会创建 fpm-worker 进程，从而导致系统并发高时 CPU 会产生频繁创建进程的开销，而 Go 不会。 golang 是先编译，后执行。由于编译方面的原因，即使是糟糕的Golang代码也会优于良好的PHP代码，从而提高性能。 由于多线程技术提高了Golang的效率，减少了部署规模，减少了内存占用量， Golang降低了企业的间接成本。 什么是守护进程？ 守护进程(daemon)是一种特殊的进程，它
golang依赖注入——wire
01-07
最近在做golang的框架，发现golang同样需要类似java中spring一样的ioc依赖注入框架。 如果项目规模小的情况下，是否有依赖注入框架问题不大，但是当项目变大之后，有一个合适的依赖注入框架是十分必要的。 通过调研...
Golang并发编程-协程goroutine任务取消(Context)
cui_win的专栏
05-25 788
在实际的业务种，我们可能会有这么一种场景：需要我们主动的通知某一个goroutine结束。比如我们开启一个后台goroutine一直做事情，比如监控，现在不需要了，就需要通知这个监控goroutine结束，不然它会一直跑，就泄漏了。我们都知道一个goroutine启动后，我们是无法控制他的，大部分情况是等待它自己结束，那么如果这个goroutine是一个不会自己结束的后台goroutine呢？比如监控等，会一直运行的。
Golang协程 与 PHP协程的概念
韩寅嵩的博客
06-20 790
协程的目的是充分利用cpu处理程序，当有io操作时会挂起，io等待时间完全忽略，已达到程序并发； php协程概念： 目前已知php可以实现协程的方法是使用swoole扩展； 模拟业务场景，比如我们要抓取豆瓣电影top250； go(){ $http = new http(); (请求class) while(ture){ $result = $http->ge...
golang：协程goroutine、管道通信channel
lena blog
08-27 659
协程 原先使用的进程线程，在进行切换的时候都要切换到内核态：在进程控制块PCB中保存中断现场，然后再将CPU恢复到下一个进程的现场。 使用协程，可以将中断现场信息保存在用户空间，对内核来说是透明的。在切换协程的时候无需切换到内核态，大大地减少了开销。 如下图，协程和线程是M:N的关系，效率高与否具体取决于协程调度器的调度。 GMP G：表示goroutine协程。 M：表示thread线程。 P：表示processor处理器。 当创建新的协程的时候，优先将其加入某一个processor处理器的本地队列，若
Golang | Leetcode Golang题解之第447题回旋镖的数量
weixin_66442839的博客
09-30 418
Golang | Leetcode Golang题解之第447题回旋镖的数量
go基础面试题汇总第一弹
weixin_43683432的博客
10-01 840
通常作为程序执行前包的初始化，例如mysql redis 等中间件的初始化。
mysql设置表的某一个字段每天定时清零
GoppViper的博客
10-04 797
这里的STARTS指定了事件开始的时间，‘2024 - 10 - 05 00:00:00’ 是一个示例时间，表示从 2024 年 10 月 5 日开始执行这个每天一次的操作。希望本文对你有所帮助！如果你有任何问题或建议，欢迎在评论区留言。2.检查和开启事件调度器（如果尚未开启）
go语言&protoc的详细用法与例子
最新发布
ruanjianxueyuan113的博客
10-04 398
讲解protoc怎么把某一个目录上的proto文件转成指定目录上的go文件，
Go基础学习08-并发安全型类型-通道（chan）深入研究
FLJS_T的博客
09-28 911
在前面学习中了解到对于单值变量，如：int、string；多值变量，如：map存在多协程对资源竞争的并发问题，为了解决并发性通常需要引入sync.Mutex解决。>对于通道的基本声明方式有三种：声明并初始化带缓冲的通道（ch1）；声明并初始化一个不带缓冲的通道（ch2）；仅仅声明一个通道（ch3） >什么是通道：==一个通道相当于一个先进先出（FIFO）的队列。也就是说，通道中的各个元素值都是严格地按照发送的顺序排列的，先被发送通道的元素值一定会先被接收。Select和for循环实现对channel的多次选
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值