Go 阻塞的实现示例_Golang

阻塞

在go语言中，阻塞通常指的是一个goroutine（轻量级线程）在等待另一个goroutine完成操作（如i/o操作、channel通信等）时，暂时停止执行的现象。go语言提供了多种同步和通信机制，可以用于实现阻塞的效果。

使用 channel 实现阻塞

channel 是go语言中的一个核心特性，用于在goroutines之间进行通信。通过channel，你可以实现阻塞等待数据或命令。

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan struct{})
	go func() {
		fmt.println("业务处理~~~")
		time.sleep(2 * time.second)
		fmt.println("业务处理完成~~~")
		close(c) // 关闭channel，通知工作完成
	}()

	<-c // 阻塞等待channel关闭
	fmt.println("处理其他业务~~~")
}

使用 waitgroup 实现阻塞

waitgroup 是go语言中用于同步一组并发操作的另一个工具。它通过计数器来跟踪完成的操作数量。

package main

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

func main() {
	var wg sync.waitgroup //控制并发组

	dowork := func(i int) {
        // wg.done(): 表示一个事件已经完成。它等价于 wg.add(-1)，但更明确地表达了“完成一个任务”的意图，并且在使用上更安全，因为它不会导致计数变为负数（如果已经到达零，则会panic）。
		defer wg.done() // 当函数返回时，通知waitgroup一个操作已完成相当于wg.add(-1)
		fmt.println("处理业务~~~" + strconv.itoa(i))
		time.sleep(2 * time.second)
		fmt.println("业务处理完成~~~" + strconv.itoa(i))
	}

	for i := 0; i < 5; i++ {
		wg.add(1)    // 增加waitgroup的计数器
		go dowork(i) // 启动一个goroutine做工作
	}
	//主goroutine调用wg.wait()，直到所有启动的goroutines都通过调用wg.done()通知它们已经完成工作
	wg.wait() // 阻塞，直到waitgroup的计数器为0
	fmt.println("所有业务处理完成~~~")
}

使用 mutex 和 conditional variables 实现阻塞

mutex（互斥锁）和条件变量可以用来同步访问共享资源，并实现基于条件的阻塞。

package main

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

func main() {
	var mtx sync.mutex         //创建互斥锁
	cond := sync.newcond(&mtx) //使用mtx作为底层互斥锁
	ready := false

	// 启动一个 goroutine 来改变条件变量 ready 的值，并通知 cond。
	go func() {
		fmt.println("循环跟goroutine是go内部决定先调度的--------------------goroutine--------------------")
		time.sleep(3 * time.second)
		mtx.lock() //使用互斥锁
		ready = true
		cond.signal() // 唤醒至少一个等待的 goroutine
		mtx.unlock()  //解锁
	}()

	mtx.lock() // 锁定互斥锁，准备进入条件等待
	for !ready {
		fmt.println("循环跟goroutine是go内部决定先调度的--------------------阻塞--------------------")
		cond.wait() // 阻塞，直到 cond.signal() 被调用
		//mtx.unlock()
	}
	mtx.unlock() // 解锁互斥锁，继续执行（此处mtx.unlock()在for循环里面阻塞等待完成后也可以，也可以没有，因为主线程会结束,但如果后续还需要获取互斥锁则必须要释放否则报错）

	fmt.println("准备继续~~~")
}

这里是一些关键的修改和注意事项：

sync.cond 的使用需要一个 sync.mutex 作为其底层的互斥锁。在使用 cond.wait() 之前，必须先锁定这个互斥锁。
在 cond.wait() 调用中，当前的互斥锁会被自动释放，goroutine 会阻塞直到它被 cond.signal() 或 cond.broadcast() 唤醒。
一旦 cond.wait() 返回，goroutine 会重新获取互斥锁，然后继续执行循环或代码块。
在 cond.signal() 调用之后，您需要在某个地方调用 mtx.unlock() 来释放互斥锁，否则主 goroutine 会在 cond.wait() 之后无法获取到锁。
您的代码中，cond.wait() 之后的 mtx.unlock() 应该在 for 循环之外，以避免在循环的每次迭代中重复加锁和解锁。

在go语言中，sync.mutex（互斥锁）用于保护共享资源不被多个goroutine同时修改，以避免竞态条件。sync.cond（条件变量）与互斥锁结合使用，可以在多个goroutine之间同步共享条件。以下是关于何时使用 mtx.lock() 和 mtx.unlock() 的指导：

mtx.lock()

在访问或修改由互斥锁保护的共享资源之前使用。
在调用 cond.wait() 之前使用，以确保在等待条件变量时，共享资源不会被其他goroutine并发访问。
在调用 cond.signal() 或 cond.broadcast() 之前使用，因为这些操作需要在互斥锁保护的临界区内执行。

mtx.unlock()

在完成对共享资源的访问或修改后使用。
在 cond.wait() 返回后使用，因为我们已经完成了等待期间需要的共享资源访问，并且需要重新获取互斥锁以继续执行。
在不再需要互斥锁保护当前goroutine的执行路径时使用，以允许其他等待互斥锁的goroutine继续执行。

注意事项

互斥锁必须在获取后及时释放，否则会导致死锁。
通常，获取互斥锁和释放互斥锁成对出现，以避免忘记释放锁。

永久阻塞

go 的运行时的当前设计，假定程序员自己负责检测何时终止一个 goroutine 以及何时终止该程序。可以通过调用 os.exit 或从 main() 函数的返回来以正常方式终止程序。而有时候我们需要的是使程序阻塞在这一行。

使用 sync.waitgroup

一直等待直到 waitgroup 等于 0

package main

import "sync"

func main() {
	var wg sync.waitgroup
	wg.add(1)
	wg.wait()
}

空 select

select{}是一个没有任何 case 的 select，它会一直阻塞

package main

func main() {
	select{}
}

死循环

虽然能阻塞，但会 100%占用一个 cpu。不建议使用

package main

func main() {
	for {}
}

用 sync.mutex

一个已经锁了的锁，再锁一次会一直阻塞，这个不建议使用

package main

import "sync"

func main() {
	var m sync.mutex
	m.lock()
}

os.signal

系统信号量，在 go 里面也是个 channel，在收到特定的消息之前一直阻塞

package main

import (
	"os"
	"os/signal"
	"syscall"
)

func main() {
	sig := make(chan os.signal, 2)
	//syscall.sigterm 是默认的终止进程信号，通常由服务管理器（如systemd、supervisor等）发送来请求程序正常终止。
	//syscall.sigint 是中断信号，一般由用户按下ctrl+c键触发，用于请求程序中断执行
	signal.notify(sig, syscall.sigterm, syscall.sigint)
	<-sig
}

从终端发送信号

ctrl+c: 在大多数unix-like系统（包括linux和macos）以及windows的命令行中，按 ctrl+c 键会向当前前台进程发送一个 sigint（中断）信号。这通常是停止go程序的快捷方式。
kill命令: 如果你的程序在后台运行，并且你知道其进程id（pid），可以通过终端发送一个信号。例如，发送一个 sigterm 信号，可以使用：kill pid或者指定型号类型kill -sigterm pid

从go代码内部发送信号

package main

import (
	"os"
	"os/signal"
	"syscall"
	"time"
)

func main() {
	sig := make(chan os.signal, 2)
	//syscall.sigterm 是默认的终止进程信号，通常由服务管理器（如systemd、supervisor等）发送来请求程序正常终止。
	//syscall.sigint 是中断信号，一般由用户按下ctrl+c键触发，用于请求程序中断执行
	signal.notify(sig, syscall.sigterm, syscall.sigint)

	go func() {
		time.sleep(10 * time.second)
		sig <- syscall.sigterm
	}()

	go func() {
		time.sleep(5 * time.second)
		sig <- syscall.sigint
	}()

	<-sig
}

使用外部工具或服务管理器

如果你的go程序作为服务运行，可能由如systemd、supervisord等服务管理器控制，这些管理器通常提供了发送信号给托管服务的机制。具体操作需参考相应服务管理器的文档。

空 channel 或者 nil channel

channel 会一直阻塞直到收到消息，nil channel 永远阻塞。

package main

func main() {
	c := make(chan struct{})
	<-c
}

package main

func main() {
	var c chan struct{} //nil channel
	<-c
}

总结

注意上面写的的代码大部分不能直接运行，都会 panic，提示“all goroutines are asleep - deadlock!”，因为 go 的 runtime 会检查你所有的 goroutine 都卡住了，没有一个要执行。

你可以在阻塞代码前面加上一个或多个你自己业务逻辑的 goroutine，这样就不会 deadlock 了。

到此这篇关于go 阻塞的实现示例的文章就介绍到这了,更多相关go 阻塞内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

Go 阻塞的实现示例

2024年06月12日 • Golang •我要评论

阻塞