Golang笔记——优秀的并发实现

于 2025-01-23 11:46:14 发布
阅读量1k 收藏 24
点赞数 32
文章标签： golang java 数据库 服务端 后端 redis 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haopingbiji/article/details/145320932
版权

大家好，这里是Good Note，关注 公主号：Goodnote，专栏文章私信限时Free。本文介绍Go并发，同步，顺序执行，设计的一些常见的场景，顺序执行主要用channel实现。在这种同步信号的使用场景中，使用无缓冲通道，可以选择不关闭通道。

在这里插入图片描述

文章目录

协程同步背景介绍

无缓冲通道（unbuffered channel）通常用于同步 Goroutine 的执行顺序。它的作用是让 Goroutines 在指定的时刻按顺序执行，而不是用来传递数据。因此，在这种同步信号传递的场景中，不需要关闭通道，程序依然能够正常运行。

无缓冲通道的作用

无缓冲通道的特性是：

  • 发送方必须等待接收方接收数据，才能继续发送下一个数据。
  • 它本质上是一个同步机制，用于协调不同 Goroutine 的执行顺序。

这种同步机制不涉及数据传输，只是信号传递。

为什么不需要关闭通道

  • 同步控制：在你的代码中，通道仅仅用于同步 Goroutine 的执行，而不用于传输实际的数据。在同步场景下，通道充当的是“信号”的角色。接收方只关心信号的到来，处理完后就继续执行，通道是否关闭不会影响这一行为。

  • 没有资源泄漏：由于通道没有存储任何数据，而是仅用于发送和接收信号，通道的关闭不会带来资源泄漏。即使不关闭通道，程序也会正确地运行，因为没有对通道进行进一步的发送操作。

  • 避免复杂性：关闭通道通常用于“通知接收方数据已经完成传输”，而在这种情况下，你只是在等待信号，不需要关心通道的关闭状态。因此，不关闭通道反而使得程序逻辑更简洁，避免了复杂的资源管理。

  • 垃圾回收机制close()：Go 的垃圾回收机制会自动处理那些不再使用的对象和数据结构，包括通道。所以即使没有显式关闭通道，程序结束时，未关闭的通道也会被垃圾回收。

何时需要关闭通道

在其他情况下，关闭通道是必要的，尤其是在以下几种场景：

  • 多接收方模式：如果你有多个接收方从同一个通道接收数据，关闭通道可以通知所有接收方没有更多的数据可以接收。

  • 通知没有更多数据：如果通道用于传输数据，关闭通道可以标识发送方不再有数据发送，这对于避免接收方阻塞和避免无限等待是非常重要的。

总结

在 无缓冲通道 的同步信号传递场景下：

  • 不关闭通道是合理的，因为通道的作用仅仅是控制同步，而不是用于传输数据。
  • 通道的关闭通常是在传输数据时，通知接收方“没有更多数据了”，而在同步信号的场景中，这种关闭操作并不必要。

所以，在 顺序执行的同步场景 中，如果你只是通过无缓冲通道传递信号，不关闭通道完全没有问题。

常见的同步场景

顺序执行10个Goroutine

这里选择了关闭channel，其实可以删掉close()，后续的例子不会再关闭channel。

package main

import (
	"fmt"
	"time"
)

func main() {
	// 创建多个无缓冲的 Channel，用来控制 Goroutine 的顺序
	steps := make([]chan struct{}, 10)
	for i := 0; i < 10; i++ {
		steps[i] = make(chan struct{})
	}

	// 定义 10 个 Goroutine，按照顺序执行
	for i := 0; i < 10; i++ {
		go func(i int) {
			if i == 0 {
				// 第一个 Goroutine 不需要等待
				fmt.Println("Goroutine 1: Start")
				time.Sleep(1 * time.Second) // 模拟工作
				fmt.Println("Goroutine 1: Done")
				// 通知 Goroutine 2 可以开始
				steps[0] <- struct{}{}
				close(steps[0])
			} else {
				// 等待上一个 Goroutine 完成
				<-steps[i-1]
				fmt.Printf("Goroutine %d: Start\n", i+1)
				time.Sleep(1 * time.Second) // 模拟工作
				fmt.Printf("Goroutine %d: Done\n", i+1)
				// 通知下一个 Goroutine 可以开始
				if i < 9 {
					steps[i] <- struct{}{}
					close(steps[i])
				} else {
					// 最后一个 Goroutine，通知主线程完成
					steps[9] <- struct{}{}
					close(steps[9])
				}
			}
		}(i)
	}

	// 等待最后一个 Goroutine 完成
	<-steps[9]
	fmt.Println("All Goroutines Finished!")
}

输出：

Goroutine 1: Start
Goroutine 1: Done
Goroutine 2: Start
Goroutine 2: Done
Goroutine 3: Start
Goroutine 3: Done
Goroutine 4: Start
Goroutine 4: Done
Goroutine 5: Start
Goroutine 5: Done
Goroutine 6: Start
Goroutine 6: Done
Goroutine 7: Start
Goroutine 7: Done
Goroutine 8: Start
Goroutine 8: Done
Goroutine 9: Start
Goroutine 9: Done
Goroutine 10: Start
Goroutine 10: Done
All Goroutines Finished!

两个 Goroutines 的交替执行，交替打印偶数和奇数

package main

import (
	"fmt"
)

func main() {
	// 定义两个channel，分别用于控制打印顺序
	ch1 := make(chan struct{})
	ch2 := make(chan struct{})
	done := make(chan struct{}) // 用于通知主协程完成

	// 启动第一个goroutine，负责打印偶数
	go func() {
		for i := 0; i <= 9; i += 2 {
			<-ch1             // 等待信号
			fmt.Println(i)    // 打印当前偶数
			ch2 <- struct{}{} // 通知另一个goroutine
		}
	}()

	// 启动第二个goroutine，负责打印奇数
	go func() {
		for i := 1; i <= 9; i += 2 {
			<-ch2          // 等待信号
			fmt.Println(i) // 打印当前奇数
			if i == 9 {
				done <- struct{}{} // 打印完成通知主协程
			} else {
				ch1 <- struct{}{} // 通知另一个goroutine
			}
		}
	}()

	// 主协程启动打印过程
	ch1 <- struct{}{} // 先给ch1发送信号，开始打印偶数

	// 主协程等待所有任务完成
	<-done
}

输出：

0
1
2
3
4
5
6
7
8
9

两个 server 的任意一个执行完成，就执行第三个

这里执行了5次，以验证随机性，time.Sleep代表server的一些执行的逻辑。

package main

import (
	"fmt"
	"time"
)

func server1(ch chan string) {
	time.Sleep(1 * time.Second)
	ch <- "server1"
}
func server2(ch chan string) {
	time.Sleep(1 * time.Second)
	ch <- "server2"
}
func main() {
	for i := 0; i < 5; i++ {
		output1 := make(chan string)
		output2 := make(chan string)
		go server1(output1)
		go server2(output2)
		select {
		case s1 := <-output1:
			fmt.Println(s1, "server3")
		case s2 := <-output2:
			fmt.Println(s2, "server3")
		}
		fmt.Println("--------------")
	}
	fmt.Println("5组执行完成")
}

输出：
下面输出5组，前面的server顺序不一定（哪个先完成都行）。

server1 server3
--------------
server2 server3
--------------
server1 server3
--------------
server1 server3
--------------
server1 server3
--------------
5组执行完成

说明：
select如果加上default会直接命中default，不会等待两个通道。

两个 server 必须全部执行完成，再执行第三个。

这里执行了5次，以验证随机性，time.Sleep代表server的一些执行的逻辑。

package main

import (
	"fmt"
	"time"
)

func server1(ch chan string) {
	time.Sleep(1 * time.Second)
	ch <- "server1"
}
func server2(ch chan string) {
	time.Sleep(1 * time.Second)
	ch <- "server2"
}
func main() {
	for i := 0; i < 5; i++ {
		output1 := make(chan string)
		output2 := make(chan string)
		go server1(output1)
		go server2(output2)
		for i := 0; i < 2; i++ {
			select {
			case s1 := <-output1:
				fmt.Println(s1)
			case s2 := <-output2:
				fmt.Println(s2)
			}
		}
		fmt.Println("server3")
		fmt.Println("--------------")
	}
	fmt.Println("5组执行完成")
}

上面使用了for+select控制2个server完成，也可以使用WaitGroup，如下：

package main

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

func server1(wg *sync.WaitGroup) {
	defer wg.Done() // 在函数退出时通知 WaitGroup

	time.Sleep(1 * time.Second)
	fmt.Println("server1")
}
func server2(wg *sync.WaitGroup) {
	defer wg.Done() // 在函数退出时通知 WaitGroup
	time.Sleep(1 * time.Second)
	fmt.Println("server2")
}
func main() {
	for i := 0; i < 5; i++ {
		wg := sync.WaitGroup{}
		wg.Add(2)
		go server1(&wg)
		go server2(&wg)
		wg.Wait()

		fmt.Println("server3")
		fmt.Println("--------------")
	}
	fmt.Println("5组执行完成")
}

输出：
下面输出5组，前面的server顺序不一定（哪个先完成都行）。

server1
server2
server3
--------------
server1
server2
server3
--------------
server2
server1
server3
--------------
server1
server2
server3
--------------
server1
server2
server3
--------------
5组执行完成

三个 server 的必须按 1 2 3 顺序执行

这里执行了5次，以验证随机性，time.Sleep代表server的一些执行的逻辑。

package main

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

func server1(ch chan string, wg *sync.WaitGroup) {
	defer wg.Done()             // 在函数退出时通知 WaitGroup
	time.Sleep(1 * time.Second) // 模拟工作
	ch <- "server1"
}

func server2(ch chan string, wg *sync.WaitGroup) {
	defer wg.Done()             // 在函数退出时通知 WaitGroup
	time.Sleep(1 * time.Second) // 模拟工作
	ch <- "server2"
}

func main() {
	for i := 0; i < 5; i++ {
		output1 := make(chan string)
		output2 := make(chan string)
		var wg sync.WaitGroup

		// 启动 server1 和 server2
		wg.Add(2) // 等待两个 Goroutine 完成
		go server1(output1, &wg)
		go server2(output2, &wg)

		// 确保按顺序输出 server1, server2, server3
		s1 := <-output1
		s2 := <-output2
		fmt.Println(s1)
		fmt.Println(s2)
		fmt.Println("server3")
		fmt.Println("--------------")
	}

	// 完成5组任务
	fmt.Println("5组执行完成")
}

输出：

server1
server2
server3
--------------
server1
server2
server3
--------------
server1
server2
server3
--------------
server1
server2
server3
--------------
server1
server2
server3
--------------
5组执行完成

一个生产者Goroutine，多个消费者Goroutine（每条消息，一次消费）

此处生产者生产的每个消息，只会有一个消费者消费，并发消费。

package main

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

func producer(ch chan int, wg *sync.WaitGroup) {
	defer wg.Done()
	for i := 1; i <= 5; i++ {
		fmt.Printf("Produced: %d\n", i)
		ch <- i // 向通道发送数据
		time.Sleep(time.Second)
	}
	close(ch) // 生产者完成后关闭通道
}

func consumer(id int, ch chan int, wg *sync.WaitGroup) {
	defer wg.Done()
	for task := range ch { // 从通道读取任务直到通道关闭
		fmt.Printf("Consumer %d processing task: %d\n", id, task)
		time.Sleep(2 * time.Second) // 模拟消费任务的延时
	}
}

func main() {
	var wg sync.WaitGroup
	tasks := make(chan int, 10) // 定义缓冲区大小为10的任务通道

	// 启动多个消费者
	for i := 1; i <= 3; i++ {
		wg.Add(1)
		go consumer(i, tasks, &wg)
	}

	// 启动生产者
	wg.Add(1)
	go producer(tasks, &wg)

	// 等待所有消费者完成工作
	wg.Wait()
	fmt.Println("All tasks completed.")
}

输出：

Produced: 1
Consumer 2 processing task: 1
Produced: 2
Consumer 1 processing task: 2
Produced: 3
Consumer 3 processing task: 3
Produced: 4
Consumer 2 processing task: 4
Produced: 5
Consumer 1 processing task: 5
All tasks completed.

一个生产者Goroutine，多个消费者Goroutine（每条消息每个消费者都会消费）

此处生产者生产的每个消息，每个消费者都会消费。
方案：

  1. 我们应该设计一个 多播机制（广播模式），即每个任务都会被多个消费者消费。最简单的方式是使用 复制通道（通过多个 goroutine 消费同一个任务通道）。

  2. 可以通过 使用多个通道，每个消费者都从这些通道中接收任务，或者使用 sync.WaitGroup 等方式来确保每个消费者都能够完成任务处理。

package main

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

func producer(channels []chan int, wg *sync.WaitGroup) {
	defer wg.Done() // 确保 producer 完成时通知 WaitGroup

	// 生产 5 个任务
	for i := 1; i <= 5; i++ {
		fmt.Printf("Produced: %d\n", i)
		// 向每个通道发送任务
		for _, ch := range channels {
			ch <- i
		}
		time.Sleep(time.Second)
	}

	// 所有任务发送完毕后，关闭每个通道
	for _, ch := range channels {
		close(ch)
	}
}

func consumer(id int, ch chan int, wg *sync.WaitGroup) {
	defer wg.Done() // 确保 consumer 完成时通知 WaitGroup

	// 从通道中接收任务并处理
	for task := range ch {
		fmt.Printf("Consumer %d processing task: %d\n", id, task)
		time.Sleep(2 * time.Second) // 模拟任务处理延迟
	}
}

func main() {
	var wg sync.WaitGroup
	numConsumers := 3
	channels := make([]chan int, numConsumers)

	// 创建多个消费者通道
	for i := 0; i < numConsumers; i++ {
		channels[i] = make(chan int, 10)
	}

	// 启动多个消费者
	for i := 1; i <= numConsumers; i++ {
		wg.Add(1)
		go consumer(i, channels[i-1], &wg)
	}

	// 启动生产者
	wg.Add(1)
	go producer(channels, &wg)

	// 等待所有消费者和生产者完成工作
	wg.Wait()
	fmt.Println("All tasks completed.")
}

输出：

Produced: 1
Consumer 1 processing task: 1
Consumer 2 processing task: 1
Consumer 3 processing task: 1
Produced: 2
Produced: 3
Consumer 1 processing task: 2
Consumer 2 processing task: 2
Consumer 3 processing task: 2
Produced: 4
Produced: 5
Consumer 2 processing task: 3
Consumer 1 processing task: 3
Consumer 3 processing task: 3
Consumer 1 processing task: 4
Consumer 2 processing task: 4
Consumer 3 processing task: 4
Consumer 3 processing task: 5
Consumer 2 processing task: 5
Consumer 1 processing task: 5
All tasks completed.

历史文章

MySQL数据库

MySQL数据库

Redis

Redis数据库笔记合集

Golang

  1. Golang笔记——语言基础知识
  2. Golang笔记——切片与数组
  3. Golang笔记——hashmap
  4. Golang笔记——rune和byte
  5. Golang笔记——channel
  6. Golang笔记——Interface类型
  7. Golang笔记——数组、Slice、Map、Channel的并发安全性
  8. Golang笔记——协程同步
Golang笔记——常用库context和runtime
m0_67266585的博客
02-10 974
context包是 Go 语言中用于处理并发操作和跨 goroutine 传递信息的重要工具。通过上下文，可以传递取消信号、超时控制、以及请求范围的数据。常用函数包括WithCancel和WithValue。context包的设计帮助开发者在并发场景中管理 goroutine 生命周期，尤其在网络请求、数据库操作等中具有重要作用。通过合理使用context，你可以在并发编程中更好地管理 goroutine、取消操作以及控制超时，确保程序的健壮性。runtime。
golang笔记——Go堆内存管理
qq_24428851的博客
08-27 1919
本文主要记录个人学习Golang堆内存管理，涉及到的相关内容，算是对个人所学知识点的梳理与总结。从非常宏观的角度看，Go的堆内存管理就是下图这个样子学习内存管理，肯定首先需要了解内存管理的基本知识，我会按照内存管理基础知识-->TCMalloc-->Go堆内存管理基础概念-->Go堆内存分配流程，这样的顺序来逐步梳理相关知识。
golang 并发顺序输出数字
weixin_30739595的博客
01-08 886
参考 package main import ( "fmt" "sync/atomic" "time" ) func main() { var count uint32 trigger := func(i uint32, fn func()) { for { if n := atomic.LoadUint32(&a...
Golang有意义的问题-并发下的有序输出
qq_17818281的博客
03-17 725
@Golang有意义的问题 和尚搬家 从前，有三个和尚，需要搬家，唯一的要求是要保证搬家前后房内物品布局一致，然后我编不下去了… 问 如何使用3个goroutine是由1-100的有序输出？ 分析 问题的核心在于如何保证在并发条件下的有序输出。 主动控制式 package main import ( "fmt" "sync" "time" ) func main() { q := make(chan int) wg := new(sync.WaitGroup) wg.Add(1) go f
golang通过协程、通道实现并发按特定顺序打印字符串
WZP_LOVE的专栏
03-22 2468
背景： 看到这样一个golang的面试题，大致是： 有三个函数分别打印，“dog”，“cat”，“fish”， 要求每个函数起一个goroutine，请按照dog，cat，fish的顺序，打印四次，输出到控制台。 怎么做： 其实这道题，就是在考察两点： 1.goroutine和channel的配合，使用来控制多个协程的执行顺序； 2.如何控制协程执行的次数； package main import ( "fmt" "sync" ) func main(){ wg:=sync.Wa
golang——channel
weixin_45627369的博客
10-07 3905
分类 channel的三种状态 channel的两种类型——有缓冲，无缓冲 无缓冲 有缓冲 2.操作 1.创建 2.发送 3.接收 4.关闭 3.使用场景 4.channel底层 5.channel线程安全 为什么是线程安全的 如何实现线程安全 6.channel控制goroutine并发执行顺序 7.channel共享内存的优缺点 8.channel发送和接收什么时候会死锁
golang channel底层剖析
qq_49723651的博客
12-19 835
golang channel底层剖析 文章目录golang channel底层剖析内存模型channel的send和recv多路selectchannel的常规send和recv操作 内存模型 type hchan struct { qcount uint // queue 里面有效用户元素，这个字段是在元素出对，入队改变的； dataqsiz uint // 初始化的时候赋值，之后不再改变，指明数组 buffer 的大小； buf unsa
golang学习笔记11——Go 语言的并发与同步实现详解
GoppViper的博客
09-09 1976
Go 语言的并发与同步机制使得开发者能够轻松地编写高效的并发程序。通过 goroutine 和 channel，开发者可以实现轻量级的并发编程，提高程序的性能和响应速度。同时，通过 mutex 和 wait group 等同步机制，开发者可以保护共享资源，确保程序的正确性。在实际开发中，开发者可以根据具体的需求选择合适的并发和同步机制，以实现高效、可靠的程序。**关注我看更多有意思的文章哦！**👉👉。
golang学习笔记32——哪些是用golang实现的热门框架和工具
最新发布
GoppViper的博客
09-25 1696
在当今的软件开发领域，Golang（Go 语言）以其高效、简洁和强大的并发性能而备受青睐。许多优秀的框架和工具都是用 Golang 实现的，本文将为大家介绍一些常见的用 Golang 实现的框架和工具，并附上代码示例帮助大家更好地理解。Kubernetes 的核心组件，如 API 服务器、控制器管理器和调度器等，都是用 Golang 编写的。总之，Golang 实现的框架和工具在各个领域都发挥着重要的作用。这个简单的例子创建了一个基本的命令行工具，当运行这个程序时，会显示简短的帮助信息。
golang学习笔记22——golang微服务中数据竞争问题及解决方案
GoppViper的博客
09-14 1572
数据竞争（Data Race）是指在多个协程同时访问和操作共享数据时，至少有一个是写操作，且没有正确的同步机制来保证数据的一致性。在 Golang 微服务开发中，数据竞争是一个必须高度重视的问题。通过合理使用互斥锁、读写锁和原子操作等同步机制，可以有效地避免数据竞争，确保微服务的稳定运行和数据的一致性。关注我看更多有意思的文章哦！👉👉。
Golang使用协程和channel顺序打印1-10
wangligen123的博客
07-09 1477
Golang使用协程和channel顺序打印1-10
golang：channel 全面解析
Hud的博客
07-09 6674
golang通道的详细解读
golang通道的顺序性保证
如切如磋，如琢如磨
03-25 1499
一个通道上的第n次成功发送操作的开始发生在此通道上的第n次成功接收操作完成之前，无论此通道是缓冲的还是非缓冲的。 一个容量为m通道上的第n次成功接收操作的开始发生在此通道上的第n+m次发送操作完成之前。 特别地，如果此通道是非缓冲的（m == 0），则此通道上的第n次成功接收操作的开始发生在此通道上的第n次发送操作完成之前。 假设通道为channel 则顺序为 开始发送-> 开始接收-&...
Golang 中 Channel 对阻塞 goroutine 的唤醒顺序分析
shida's blog
03-08 4534
一、前言 我们知道，goroutine 是有大小的，当 发送满/读取空时，会阻塞对应的 发送/读取 goroutine 协程。 那么，当 Channel 可用时，它是按照什么顺序唤醒等待的 goroutine 协程的呢？ 带着这个问题，我们深入 chan 的源码逻辑，去一探究竟。 剧透结论：先阻塞的先被唤醒！ 二、chan 源码分析...
golang channel的使用技巧
D_Guco的专栏
11-25 6431
go的横空出世，让很多人眼前一亮，它的语法以简洁著称，并且它对多核并发的原生支持，让他在云计算和分布式领域展露头脚，它的核心围绕channel和goroutine展开。下面我们来介绍一下channel的基本用法。 1 信号量的传递
Golang实现带优先级的channel
RayXXZhang的专栏
11-25 4648
在go语言中，如果select/case中没有default子句，则程序会阻塞在select中，直到其中一个case语句接收到了数据。 如果有default语句，则不会阻塞，如果case接收到数据，就执行case中的语句，如果case未收到信号，则会执行defalut中的语句，随后跳出select块。 使用这个特性可以实现带优先级的channel队列。
golang 实现goroutine顺序输出
weixin_42447373的博客
06-11 634
golang 实现goroutine顺序输出 原理：waitgroup 保证协程阻塞，执行完毕。chan是有序的（先进先出）保证循序执行。 func main() { str := make([]string, 0) str = append(str, "1") str = append(str, "2") str = append(str, "3") str = append(str, "4") str = append(str, "5") str = append(str, "6")
golang goroutine顺序输出
wenhao的专栏
12-05 2604
golang goroutine顺序输出range字符串，使用goroutine打印，因为goroutine随机执行for _, v := range str { go func() { fmt.Println(string(v)) }() }输出：5 5 5 5 5可以使用chan顺序输出 for _, c := range str{
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值