Go语言头秃之路（六）

最新推荐文章于 2025-11-02 19:38:36 发布
原创 最新推荐文章于 2025-11-02 19:38:36 发布 · 176 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Go

本文深入探讨Go语言的协程特性，包括协程的轻量级线程属性、与线程的区别、Go的MPG模式、互斥锁与读写锁、管道channel的使用、并发安全与死锁预防，以及context在控制协程同步关闭中的应用。通过实例解析，帮助理解Go语言的并发优势和资源管理。

更新系列

Go语言头秃之路（零）
Go语言头秃之路（一）
Go语言头秃之路（二）
Go语言头秃之路（三）
Go语言头秃之路（四）
Go语言头秃之路（五）

  • 协程(goroutine)

    • 协程特点：（面试）
    1. 有独立的栈空间；
    2. 共享程序堆空间；
    3. 调度由用户控制；
    4. 协程是轻量级的线程。
    • 线程和协程
    1. 主线程是一个物理线程，是内核态，直接作用在CPU上，比较耗费CPU资源；
    2. 协程从主线程开启，是轻量级线程，是逻辑态，对资源消耗相对小；
    3. 如果主线程退出了，则线程即使还没有执行完毕，也会退出；（主死从随）
    4. golang的协程机制是重要的特点，可以轻松的开启上万个协程。（并发优势）
    5. 与go相比，python协程占用cpu/内存资源较少（如下程序运行时观察资源使用情况）
      package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup

func main() {
    // Add数量必须和Done数量相同
	wg.Add(5)
	for i := 0; i < 5; i++ {
		go func(n int) {
			defer wg.Done()
			fmt.Println(n)
		}(i)
	}
	wg.Wait()
}


      import asyncio


async def func1(n):
    while True:
        print(n)
        await asyncio.sleep(1)


async def main():
    for i in range(100000):
        # 运行协程，阻塞协程直到返回结果
        # await func1(i)
        asyncio.create_task(func1(i))
    await asyncio.sleep(10)


asyncio.run(main())
    • MPG模式
    1. M：操作系统主线程（物理线程）
    2. P：协程执行需要的上下文（需要的资源）
    3. G：协程
      运行状态描述：
      在这里插入图片描述

    • 设置使用逻辑CPU个数 runtime包
      runtime.NumCPU()：查看程序使用CPU个数，在go1.8之后默认使用多个cpu；
      runtime.GOMAXPROCS(2)：设置程序使用cpu个数，在go1.8之前版本设置后可以提高程序执行效率。

    • 互斥锁：解决资源竞争(low版)
      sync.Mutex
      能不用锁尽量不用：性能损耗

      // 使用goroutinue计算10的阶乘
package main

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

var (
	jiecheng = make(map[int]uint, 1)
	// 全局互斥锁
	lock sync.Mutex
)

func jc(n int) {
	var res uint = 1
	for i := 1; i <= n; i++ {
		res *= uint(i)
	}
	lock.Lock()
	jiecheng[n] = res
	lock.Unlock()
}

func main()  {
	for i := 1; i <= 10; i++ {
		go jc(i)
	}

	// 解决：fatal error: concurrent map read and map write
	time.Sleep(time.Second * 10)

	lock.Lock()
	for j := 1; j <= 10; j++ {
		fmt.Printf("%d 的阶乘为 %d\n", j, jiecheng[j])
	}
	lock.Unlock()
}

    • 读写锁
      sync.RWMutex

      package main

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

var wg sync.WaitGroup

// 读写锁
var rwLock sync.RWMutex

func read() {
	defer wg.Done()
	rwLock.RLock()
	fmt.Println("开始读取...")
	time.Sleep(time.Second)
	fmt.Println("读取完成。")
	rwLock.RUnlock()
}

func write() {
	defer wg.Done()
	rwLock.Lock()
	fmt.Println("开始写入...")
	time.Sleep(time.Second)
	fmt.Println("写入完成。")
	rwLock.Unlock()
}

func main() {
	wg.Add(6)
	for i := 0; i < 5; i++ {
		go read()
	}
	go write()
	wg.Wait()
}

  • 管道(channel)
    channel本质是一个数据结构 - 队列；
    数据按照先进先出原则（FIFO）；
    管道是线程安全的，多goroutinue访问时，不需要加锁；
    channel是有类型的，一个string的channel只能存放string类型数据。

    声明语法：var 变量名 chan 数据类型
    eg：var intChan chan int
    channel是引用类型，必须初始化(make)才能写入数据，管道make的时候定义的数据容量不能更改
    从管道取一个数据后，管道长度会 -1 ，而容量不变。
    无论容量存满再放入数据还是从空管道取数据都会报死锁(deadlock!)
    使用任意类型的管道，即接口interface{}需要使用其中的属性或方法时，需要先进行类型断言。
    遍历管道最好使用 for v:= range channel方式，注意这里只接收一个值v
    管道遍历前需要关闭管道close(channel)，如果管道没有关闭，最后会报错deadlock
    如果编译器发现一个管道只有写没有读，则该管道会阻塞死锁(deadlock!)
    如果写管道和读管道的频率不一致，小炒面不报错。

    type Cat struct {
	Name string
	Age int
}
var intChan chan interface{}
intChan = make(chan interface{}, 3)
cat1 := Cat{"miaomiao", 1}
// 往管道写入数据
intChan <- 6
intChan <- cat1 
fmt.Printf("intChan:%v \t %T\n", intChan, intChan)
fmt.Printf("len: %v, cap: %v\n", len(intChan), cap(intChan))
// 从管道读取数据，丢弃则不写变量，如<- intChan
n1 := <- intChan
fmt.Printf("len: %v, cap: %v\n", len(intChan), cap(intChan))
getCat := <- intChan
// 这里直接取getCat.Name编译不通过
cat2 := getCat.(Cat)
fmt.Println(cat2.Name)
// 遍历前关闭管道，管道关闭后不能再写入数据，但是可以读取数据
close(intChan)
// 遍历管道
for v := range intChan {
	fmt.Println(v)
}
    • 注意事项：

    1. 默认情况下，管道为双向（可读可写），对于一些特殊情况（一般在函数参数中，防止误操作）可以将管道声明为只读（receive-only 箭头在前面）或只写（send-only 箭头在后面）。
      双向管道可以以参数形式传递给单项管道。
      eg：只读 intChan <- chan int
      只写 intChan chan <- int

    2. 当不确定何时关闭管道时，使用select语句

      intChan := make(chan int, 3)
for i := 0; i < 3; i++ {
	intChan <- i
}
// defer close(intChan)

stringChan := make(chan string, 6)
for j := 0; j < 6; j++ {
	stringChan <- "hello" + fmt.Sprint(j)
}
// defer close(stringChan)

for {
	select {
		// 使用select语句，即使管道没有关闭也不会报 deadlock 
		case v := <- intChan:
			fmt.Println("从intChan取到：", v)
		case v2 := <- stringChan:
			fmt.Println("从stringChan取到：", v2)
		default:
			fmt.Println("取不到数啦。。")
			return
	}
}

    3. context：控制主协程和子协程同步关闭
      ctx, cancel := context.WithCancel(parent Context)：需要手动执行cancel()
      传入的是父context，当父context退出时，子context也会跟着退出.
      ctx, cancel := context.WithTimeout(parent Context, timeout time.Duratio)：指定超时时间后自动关闭，不需要手动执行cancel()，当然也可以手动执行。
      ctx, cancel := context.WithDeadline(parent Context, d time.Time)：到了哪个时间自动退出。
      在web开发中比较常用。

      package main

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

var wg sync.WaitGroup

func cpuInfo(ctx context.Context) {
	defer wg.Done()
	ctxx, _ := context.WithCancel(ctx)
	go memoryInfo(ctxx)
	for {
		select {
		case <-ctx.Done():
			fmt.Println("退出CPU监控。")
			return
		default:
			fmt.Println("实时CPU监控...")
			time.Sleep(time.Second)
		}
	}
}

func memoryInfo(ctxx context.Context) {
	defer wg.Done()
	for {
		select {
		case <-ctxx.Done():
			fmt.Println("退出内存监控。")
			return
		default:
			fmt.Println("实时内存监控...")
			time.Sleep(time.Second)
		}
	}
}

func main() {
	wg.Add(2)
	// context.WithCancel()中传入的是父context，当父context退出时，子context也会跟着退出
	ctx, cancel := context.WithCancel(context.Background())
	go cpuInfo(ctx)
	time.Sleep(time.Second * 3)
	cancel()
	wg.Wait()
}

    4. 防止因为某个协程报错而整个程序异常退出：
      在协程中使用defer+recover来捕获panic。

      // 在方法开头加入代码
defer func() {
	if err := recover(); err != nil {
		fmt.Println("发送邮件：执行报错了", err)
	}
}()

      panic会引起主线程挂掉，同时会导致其他的协程都挂掉；
      在父协程中无法捕获子协程中出现的异常，需要分别进行捕获。

1、Go语言系统调用入门指南
vscode6remote的博客
09-18 27
本文介绍了Go语言中系统调用的基本概念与使用方法，对比了C语言中的系统调用实现，并详细讲解了Go语言通过sys/unix和syscall包进行系统级操作的方式。内容涵盖获取进程信息、文件状态统计、磁盘空间检测等实例，帮助开发者深入理解Go如何与底层操作系统交互。
Go 语言的异常处理
weixin_64314555的博客
12-10 1784
ERROR 是什么 对于一个 Go 语言程序员，你一定写过这样的代码。 if err != nil { doSomething() } 复制代码 这里的 err 便是我们今天要讨论的主角，为了解释它是什么这个问题，我们不妨先从设计者的角度出发，看一看标准库里的 errors 包是如何设计的。 // because the former will succeed if err wraps an *fs.PathError. package errors // New returns an
Channel管道的基础
weixin_44006496的博客
11-01 723
Channel管道的基础（一） func main(){ ch := make(chan interface{}) // 无缓冲管道 对于没有缓存的通道，需要接收方实时接收数据，否则会报错 ch1 := make(chan interface{}, 10) // 带缓冲区的管道 // 向管道发送数据 ch1 <- struct{} ch1 <- 0 ch1 <- "hello" select{ // 专门用来选
Go语言通道（chan）——goroutine之间通信的管道
xyz的专栏
09-05 359
如果说 goroutine 是 Go语言程序的并发体的话，那么 channels 就是它们之间的通信机制。一个 channels 是一个通信机制，它可以让一个 goroutine 通过它给另一个 goroutine 发送值信息。每个 channel 都有一个特殊的类型，也就是 channels 可发送数据的类型。一个可以发送 int 类型数据的 channel 一般写为 chan int。 Go语言提倡使用通信的方法代替共享内存，当一个资源需要在 goroutine 之间共享时，通道在 goroutin..
go语言的channel笔记
qq_41358574的博客
11-03 451
同理，如果缓冲通道中有数据，接收时将不会发生阻塞，直到通道中没有数据可读时，通道将会再度阻塞。·第11行，使用了time包提供的函数After()，从字面意思看就是多少时间之后，其参数是time包的一个常量，time.Second表示1秒。由于通道的数据在没有接收方处理时，数据发送方会持续阻塞，因此通道的接收必定在另外一个goroutine中进行。·第18行，匿名goroutine即将结束时，通过通道通知main的goroutine，这一句会一直阻塞直到main的goroutine接收为止。
详解go语言 make(chan int, 1) 和 make (chan int) 的区别
12-23
遇到golang channel 的一个问题：发现go 协程读取channel 数据 并没有按照预期进行协作执行。 经过查资料： 使用channel 操作不当导致,channel分 有缓冲区 和 无缓冲区 , 以下是两者的区别。 无缓冲区channel 用make(chan int) 创建的chan, 是无缓冲区的, send 数据到chan 时，在没有协程取出数据的情况下， 会阻塞当前协程的运行。ch <- 后面的代码就不会再运行，直到channel 的数据被接收，当前协程才会继续往下执行。 ch := make(chan int) // 创建无缓冲channel go func() {
Go语言头秃之路（一）
super2feng博乐世界
02-03 211
各种基础语句
Go语言和golang语言
06-05
golang是Go语言的别名，通常在命令行中使用golang会自动调用Go语言的编译器和相关工具。Go语言在各大平台都有编译器支持，包括Windows、Mac OS X、Linux等。同时，Go语言还提供了一些常用的命令行工具，例如go build...
Go语言中安全停止Goroutine的三种方法及设计哲学
weixin_48552411的博客
08-15 1539
本文介绍了Go语言中安全停止Goroutine的三种常用方法：1）通过close关闭Channel触发Goroutine退出，适用于简单生产者-消费者模型；2）利用select轮询停止信号，实现多事件处理的灵活控制；3）使用context包进行标准化生命周期管理，适合复杂调用链场景。文章分析了每种方法的优缺点和适用场景，并解释了Go语言不支持强制终止Goroutine的设计哲学——通过通信实现协同退出，避免资源泄露和逻辑混乱。开发者应根据业务复杂度选择合适方案，在保证程序健壮性的同时遵循Go语言的并发设计理
GO语言基础教程（222）Go文件处理：Go文件操作：从青铜到王者的通关秘籍
jxf_jxfcsdn的博客
11-02 633
还在为Go语言文件操作头秃吗？这篇256字速览带你轻松玩转文件读写！从基本IO到高级并发处理，从常见坑点到性能优化技巧，用最接地气的代码示例讲解创建、读取、写入、追加等核心操作。无论你是刚入门的新手还是想查漏补缺的老鸟，这份避坑指南都能让你快速掌握Go文件处理精髓，告别IO混乱，写出更稳健的代码！
Golang学习笔记(一)
weixin_34248023的博客
06-25 256
2019独角兽企业重金招聘Python工程师标准>>> ...
Go学习笔记（七）
weixin_34054931的博客
05-27 129
（文章持续更新中...有志同道合的人可以一起探讨下。整个系列（1～8）准备重写，不过都是很基础的入门笔记，想学到很深入的东西则不建议阅读...） 接口是双方约定的一种合作协议。每个接口类型由数个方法组成 type 接口类型名 interface{ 方法名1( 参数列表1 ) 返回值列表1 方法名2( 参数列表2 ) 返回值列表2 … } type Writer inter...
Golang make chan 第二个参数(size)
热门推荐
天南之南
05-17 1万+
目录说明无参数示例输出 (无size 或 size=0)输出 (size=1)输出 (size=3) 说明 func make(t Type, size ...IntegerType) Type 指出该值在同一时刻最多可以容纳 size 个元素值。 如果我们发送给该通道的元素值未被取走，那么该通道最多可以暂存（或者说缓冲）size 个元素值。 当发送第size +1个元素值后, 会造成当前Gor...
golang的数组、切片理解
weixin_43957354的博客
03-18 653
一、数组 1.数组的初始化 var a [5]int a[0]=1 a[1]=2 var a1 [3]int = [3]int{1,2,3} var a2 = [3]int{1,2,3} var a3 = [...]int{1,2,3} var a4 = [...]int{2:800,1:900,3:999} a5:= [...]string{2:"tom",1:"jack",3:"mary"} //类型推导 fmt.Println(a1) //[1 2 3] fmt.Println(a2)
go 通过channel异步读写切片，切片内容不符预期
DisMisPres的博客
03-10 898
记录一下异步读写的问题，使用通道切片，切片内容问题
高等院校如何建立跨部门数据共享安全规范？.docx
12-16
高等院校如何建立跨部门数据共享安全规范？
高校如何提升转化指标在职称评审中的权重？.docx
12-16
高校如何提升转化指标在职称评审中的权重？
安卓应用源码Android仿快播搜索框上方悬浮的文字搜索源码
最新发布
12-16
安卓应用源码Android 仿快播搜索框上方悬浮的文字搜索源码
Golang学习进阶之路：掌握Go语言的关键技巧
资源摘要信息:"Golang-Learning:Golang的学习之旅" 知识点: 1.Go语言简介:Go语言是一种开源的编程语言，由Google公司开发，主要用于系统编程。它具有简洁、快速、安全、并行等特点，非常适合用于并发编程。Go语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值