. Goroutines
概念:
Goroutines 是 Go 的核心并发机制。它们是由 Go 运行时管理的轻量级线程,具有比操作系统线程更少的开销。每个 goroutine 只需少量的内存(大约 2KB),并且由 Go 运行时负责调度和管理,哪怕是java发展到21的虚拟线程和go比也还是不够轻量
创建:
go func() {
fmt.Println("Hello from goroutine")
}()
使用 go 关键字前缀一个函数调用即可创建一个新的 goroutine。它将异步执行指定的函数。
调度模型:
Go 使用 M调度模型,其中 M 个用户级线程(goroutines)通过 N 个操作系统线程(OS threads)进行调度。Go 运行时会动态地将 goroutines 分配到操作系统线程上,减少了上下文切换的开销。
底层原理:
Go 的调度器使用协作式调度,依靠 goroutine 的堆栈跟踪(stack traces)和调度策略(如抢占式调度)来管理并发执行。调度器负责在 goroutines 和 OS threads 之间进行合理分配,以实现高效的并发执行。
###Channel
概念:
Channel 是用于 goroutine 之间通信的管道,可以安全地传递数据。它们实现了数据传递的同步机制,避免了传统的锁竞争问题。
创建:
ch := make(chan int)
发送和接收:
// 发送数据
ch <- 42
// 接收数据
value := <-ch
//数据通过 <- 操作符在 channel 中发送和接收。发送操作会阻塞直到有接收方,接收操作会阻塞直到有发送方。
这样就可以简单模拟java的join 操作 ,只有上一个任务执行完才允许接下来的线程执行
func testTrueCache() {
//如果是无缓冲的 需要立即读取 所以异步写入
ch := make(chan string)
go func() {
fmt.Println("hello")
ch <- "hello"
}()
fmt.Println(<-ch)//不采用读取 那么可能子携程还没有执行主协诚就结束了
fmt.Print("这个输出第一是在hello之后")
}
缓冲区:
无缓冲 channel:发送和接收操作必须匹配,否则会阻塞。
注意 串行的代码块不能写如通道会立即死锁 ,因为 无缓冲通道在写入数据时必须立刻有其他协程来读取数据,否则会导致阻塞。串行中,写入数据和读取数据是在同一个协程中进行的,阻塞后根本不会执行下一个代码 这会导致死锁。
func testFialChannelCache() {
// 创建无缓冲管道
ch := make(chan int) // 正因为无缓冲管道无法存放数据,在向管道写入数据时必须立刻有其他协程来读取数据
defer close(ch)
// 启动一个新的协程来读取数据
go func() {
n := <-ch
fmt.Println(n)
}()
// 写入数据
ch <- 123 // 不在串行 写入后必须读取 没有容量可以保存 会报错
}
缓冲 channel:创建时指定缓冲区大小,发送操作只有在缓冲区满时才会阻塞,接收操作只有在缓冲区空时才会阻塞。
go
ch := make(chan int, 2) // 创建一个缓冲区大小为 2 的 channel
关闭:
可以使用 close 函数关闭 channel,以表明没有更多数据将被发送。
//建议创建号channel后就使用
defer close(ch)
关闭后的 channel 仍然可以读取数据,但不能再发送数据。读取操作会返回 channel 的零值。
底层原理:
Channel 是基于锁和条件变量实现的。每个 channel 有一个缓冲区和一个互斥锁,用于协调数据的发送和接收操作。
只读通道和只写通道的申明创建
var ch <-chan int // 只读通道,只能接收 int 类型的数据
var ch chan<- int // 只写通道,只能发送 int 类型的数据
WaitGroup
刚才使用无缓冲的通道模拟 java中的join api 效果
概念:
sync.WaitGroup 用于等待一组 goroutine 完成任务,确保所有并发操作完成后才继续执行。
var wg sync.WaitGroup
wg.Add(1) // 增加等待计数
go func() {
defer wg.Done() // 任务完成时减少计数
// 任务代码
}()
wg.Wait() // 等待所有任务完成
底层就是维护了一个原子性的任务数 wg.Done() 进行任务数自减1wg.Wait() // 等待所有任务完成 只有为0才会进行执行
这样就更直观的可以发出来 可以保证多个无序携程的有序性
func quicktest() {
var wait sync.WaitGroup
// 指定子协程的数量 本质是原子性的自增自减
wait.Add(1) //自增
go func() {
fmt.Println(1)
// 执行完毕
wait.Done() //自减
}()
// 等待子协程
wait.Wait() //判断是否为0 阻塞等待 只有为0才会继续执行 这样就保证了执行的有序性
wait.Add(1)
go func() {
fmt.Println(2)
// 执行完毕
wait.Done() //自减
}()
wait.Wait()
wait.Add(1)
go func() {
fmt.Println(3)
// 执行完毕
wait.Done() //自减
}()
wait.Wait()
wait.Add(1)
go func() {
fmt.Println(4)
// 执行完毕
wait.Done() //自减
}()
// 等待子协程
wait.Wait() //判断是否为0 阻塞等待
fmt.Println("完成")
}
Select
概念:
select 语句允许一个 goroutine 等待多个 channel 操作,并在其中一个操作准备好时执行相应的代码块。它类似于 Java 中的 Selector,用于处理多个异步事件,和netty一样 用到了seletor 多路复用思想
使用:
go
基本用法 类似 swtich case go中的stich 不会像Java一样需要显示申明return返回
select {
case msg := <-ch1:
fmt.Println("Received from ch1:", msg)
case msg := <-ch2:
fmt.Println("Received from ch2:", msg)
case <-time.After(time.Second):
fmt.Println("Timeout")
}
select 语句会阻塞,直到其中一个 case 准备好。time.After 是一个用于超时的示例,它创建一个定时器 channel。
默认分支:
可以使用 default 分支来避免 select 阻塞。
func main() {
test()
}
func test() {
chA := make(chan int)
chB := make(chan int)
chC := make(chan int)
defer func() {
close(chA)
close(chB)
close(chC)
}()
// 开启一个新的协程
go func() {
// 向A管道写入数据
chA <- 1
}()
go func() {
// 向A管道写入数据
chB <- 1
}()
go func() {
// 向A管道写入数据
chC <- 1
}()
// 选择器 这样就可以监控 多个通道 有数据的时候就触发 如果都没有数据 就阻塞
// 这里的select 语句会阻塞,直到有某个通道有数据可读
//如果都同时 检查到有数据可读,则随机选择一个进行读取
Loop: //break Loop 后不会执行:后的代码了
for {
select {
case n, ok := <-chA:
fmt.Println("写入通道A")
fmt.Println(n, ok)
case n, ok := <-chB:
fmt.Println("写入通道B")
fmt.Println(n, ok)
case n, ok := <-chC:
fmt.Println("写入通道C")
fmt.Println(n, ok)
//超时时间跳出进行下一次循环
case <-time.After(time.Second): // 设置1秒的超时时间 //返回只读通通道
break Loop // 退出循环 避免死循环锁毒素 还可以一直监听
}
}
}
底层原理:
select 通过轮询和系统调用来检查多个 channel 的状态,使用系统级的 poll 或 epoll(在 Linux 上)机制来实现高效的 I/O 多路复用。
锁
go中的锁也相对轻量
Mutex(互斥锁):
概念:
sync.Mutex 用于保护临界区,确保在同一时间只有一个 goroutine 可以访问共享资源。
使用:
var mu sync.Mutex
mu.Lock()
// 临界区代码
mu.Unlock()
比如这种代码进行应用
/*
*
这种情况肯定是脏数据的 10个携程并发执行肯定有脏数据 并且还无法确 还没有等待确定有序性
解决方案:
. 加锁 互斥锁l
*/
func main() {
wait.Add(10) // 等待10个协程完成
for i := 0; i < 10; i++ {
go func(data *int) {
// 模拟访问耗时
// 加锁 同一时间只有有所的次啊可以执行
lock.Lock()
time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000)))
// 访问数据
temp := *data
// 模拟计算耗时
time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000)))
ans := 1
// 修改数据
*data = temp + ans
lock.Unlock() //数据修改完毕了才可以解锁
fmt.Println(*data)
wait.Done()
}(&count)
}
wait.Wait()
fmt.Println("最终结果", count)
}
只有数据处理时候加锁才能保证有序性,多个携程并发处理数据 会造成脏数据
底层原理:基于自旋锁和操作系统的原子操作实现,使用互斥锁来保护数据的一致性。
RWMutex(读写锁):
概念:
sync.RWMutex 允许多个 goroutine 同时读取数据,但在写操作时独占访问。本质就是为了优化读写分离的情况,写锁还是写携程之间互斥,读锁是为了保证有读锁的携程允许时候写锁的携程就堵塞
func main() {
wait.Add(12) //12个任务携程
// 读多写少
go func() {
for i := 0; i < 3; i++ {
go Write(&count)
}
wait.Done()
}()
go func() {
for i := 0; i < 7; i++ {
go Read(&count)
}
wait.Done()
}()
// 等待子协程结束
wait.Wait()
fmt.Println("最终结果", count)
}
func Read(i *int) {
time.Sleep(time.Millisecond * time.Duration(rand.Intn(500)))
rw.RLock()
fmt.Println("拿到读锁")
time.Sleep(time.Millisecond * time.Duration(rand.Intn(1000)))
fmt.Println("释放读锁", *i)
rw.RUnlock()
wait.Done()
}
func Write(i *int) {
time.Sleep(time.Millisecond * time.Duration(rand.Intn(1000)))
rw.Lock()
fmt.Println("拿到写锁")
temp := *i
time.Sleep(time.Millisecond * time.Duration(rand.Intn(1000)))
*i = temp + 1
fmt.Println("释放写锁", *i)
rw.Unlock()
wait.Done()
}
Context
概念:
context 包用于在 goroutine 中传递取消信号、截止时间和请求范围的信息,类似于 Java 中的 Future 或 ExecutorService 的取消机制。
在 Go 中,context 包提供了上下文管理的功能,主要用于控制 goroutine 的生命周期、传递请求范围的值以及处理超时和取消信号。context 是在并发编程中不可或缺的工具,尤其是在处理网络请求和后台任务时。
Context 的主要用途
-
控制 goroutine 的生命周期:通过 context,你可以在父任务结束或取消时,通知所有子 goroutine 停止执行,从而避免 goroutine 泄漏。
-
传递请求范围的值:context 可以在函数调用链之间传递值,这些值通常是与请求有关的信息,比如用户身份、授权令牌、请求截止时间等。
-
处理超时和取消信号:context 可以设定超时时间或在外部取消信号时终止操作,这对于网络请求和长时间运行的任务非常有用。
Context 的类型
- context.Background():通常作为主函数的起点使用,表示一个空的上下文。
- context.TODO():当你还不确定要用什么样的上下文时,可以使用它作为占位符。
Context 的使用模式
在实际编程中,context 通常以以下几种方式使用:
取消任务:
当需要在某个操作完成后取消所有相关的 goroutine 时,使用 context.WithCancel。
超时控制:
当一个操作需要在指定时间内完成时,使用 context.WithTimeout。
截止时间控制:
与超时类似,但使用的是具体的时间点而不是时间间隔,使用 context.WithDeadline。
Context 实例详细讲解
go
package main
import (
"context"
"fmt"
"time"
)
// 模拟一个处理请求的函数
func processRequest(ctx context.Context, duration time.Duration) {
select {
case <-time.After(duration):
fmt.Println("Request processed")
case <-ctx.Done():
fmt.Println("Request canceled:", ctx.Err())
}
}
func main() {
// 创建一个 context,设置超时时间为 3 秒
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel() // 确保取消函数被调用,以释放资源
// 启动一个 goroutine 来处理请求,预计处理时间为 5 秒
go processRequest(ctx, 5*time.Second)
// 模拟一些其他操作
time.Sleep(2 * time.Second)
// 主 goroutine 等待 6 秒,以便观察子 goroutine 的处理情况
time.Sleep(6 * time.Second)
fmt.Println("Main function ends")
}
详细解释
创建 Context:context.WithTimeout(context.Background(), 3*time.Second) 创建了一个有超时限制的 context,3 秒后自动取消。
处理请求:processRequest 是一个模拟的请求处理函数,它要么在指定的 duration 后完成请求处理,要么在 context 被取消时停止操作。
启动 goroutine:我们在主函数中启动了一个 goroutine 来处理请求,这个 goroutine 模拟了一个 5 秒的处理时间。
观察取消效果:由于 context 设置的超时时间是 3 秒,而请求的处理时间是 5 秒,3 秒后 context 会被自动取消,导致 processRequest 提前退出并输出取消原因。
实际用途
在实际应用中,context 经常用于以下场景:
API 请求的超时控制:确保 API 请求在设定的时间内完成,避免服务阻塞。
批量任务的并发处理:在父任务取消时,自动终止所有子任务,避免资源浪费。
数据库操作:结合 context 来设置数据库查询的超时时间,确保数据库操作不会无限制地阻塞。
go中的池化技术–工作池
即使 Goroutine 很轻量,但在某些情况下,仍需要限制同时运行的 Goroutine 数量:
资源限制:
当每个任务都涉及到大量的资源(如 CPU、内存、网络)时,过多的 Goroutine 会导致资源竞争,影响系统性能。
后端服务限制:如果你的程序需要调用外部服务或数据库,这些服务可能有并发连接的限制,需要控制并发量。
稳定性和可控性:使用工作池可以更好地管理任务的执行,提供任务队列、超时、重试等机制,提升系统的稳定性和可靠性。
工作池的作用:
限制并发数:
通过固定数量的工作 Goroutine,限制同时执行的任务数量。
任务调度:将任务放入队列,等待空闲的 Worker 处理。
结果收集:汇总任务执行的结果,方便后续处理。
错误处理:统一管理任务执行中的错误和异常。
在 Go 中,实现工作池通常有以下几种方式:
使用 Channel 实现简单的工作池:通过创建一定数量的 Worker Goroutine,从任务 Channel 中获取任务并执行。
使用同步包(如 sync.WaitGroup)协调任务执行:确保所有任务执行完毕后再进行后续操作。
使用第三方库:社区中有一些成熟的工作池库,如 antlabs/workerpool、gammazero/workerpool 等,提供了丰富的功能和更好的性能。
接下来,下面的代码示例来演示如何在 Go 中实现工作池。
// 任务类型
type Task struct {
id int
}
// 模拟处理任务的方法
func (t Task) Process() {
fmt.Printf("Processing task with id: %d\n", t.id)
time.Sleep(time.Second) // 模拟任务处理耗时
}
// 工作池函数
func worker(id int, tasks <-chan Task, wg *sync.WaitGroup) {
defer wg.Done()
for task := range tasks {
fmt.Printf("Worker %d started task %d\n", id, task.id)
task.Process()
fmt.Printf("Worker %d finished task %d\n", id, task.id)
}
}
func main() {
const numWorkers = 3 // Worker 的数量
const numTasks = 10 // 任务的数量
tasks := make(chan Task, numTasks) // 创建一个任务通道
var wg sync.WaitGroup
// 启动 worker
for i := 1; i <= numWorkers; i++ {
wg.Add(1)
go worker(i, tasks, &wg)
}
// 发送任务到任务通道
for i := 1; i <= numTasks; i++ {
tasks <- Task{id: i}
}
close(tasks) // 关闭任务通道,不再发送新任务
// 等待所有 worker 完成
wg.Wait()
fmt.Println("All tasks processed")
}
详细解释
- Task 类型:
这是一个简单的任务类型,其中包含了任务的 ID。Process 方法模拟任务的处理过程。
Worker 函数:
worker 函数是每个 worker 执行的工作。它从 tasks 通道中接收任务,并调用 Process 方法处理任务。sync.WaitGroup 用于等待所有 worker 完成任务。
- 启动 Worker:
numWorkers 决定了 worker 的数量。在这里,启动了 3 个 worker。
发送任务:
- 将 numTasks 数量的任务发送到 tasks 通道,任务会被 worker 逐一处理。
关闭通道:
任务发送完毕后,关闭任务通道,告诉所有 worker 没有更多的任务了。
等待所有 Worker 完成:
使用 sync.WaitGroup 确保主程序在所有 worker 完成任务后再退出。
Java 线程池通过 Executors 工具类来创建不同类型的线程池,Go 则通过自定义的 worker pool 和 goroutine 来管理并发