Go语言实战-第六章 并发

于 2024-09-11 16:29:46 发布
阅读量650 收藏 19
点赞数 27
文章标签： golang php 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39167720/article/details/141684466
版权

通常程序以独立方式编写，简单易维护，但一些时候处于性能考量就需要并发，go语言的并发是基于csp模型的，通信顺序进程（Communicating Sequential Processes，CSP），不像其他语言对数据加锁，而是通过使用通道channel在gorountine中传递信息

并发与并行

并发的概念是离不开程序进程与线程的概念的，通常进程指一个运行的程序，其中包含了线程，启动时的线程是主线程，操作系统会调度线程，1.5前每个可用的物理处理器分配一个逻辑处理器，1.5后整个应用程序则只分配一个逻辑处理器，来调度所有的goroutine
在这里插入图片描述
如图，调度器将goroutine排列到队列里，绑定线程，将goroutine依次执行，如果系统调用阻塞的话，就新开线程等待返回，同时继续处理下一个routine，而针对网络io的话，阻塞时routine会与逻辑处理器分离，放到网络轮询器的运行时上，当网络轮询器指示操作就绪时，再回到逻辑处理器执行
逻辑处理器数量没有上限，但线程数默认10000，超过就会崩溃，可以通过调用runtime/debug包的SetMaxThreads方法来更改
并发不同于并行，它不是同时执行多个，而是调配管理多个，在合适的时机处理合适的任务，在有限的硬件资源下，具有更好的表现
如果要实现并行，就要有多个逻辑处理器，调度器会平均分配routine到多个线程，并且要有多个物理处理器，这样才能达到并行的效果
在这里插入图片描述
如图是并发与并行的区别

goroutine
// 这个示例程序展示如何创建goroutine
// 以及调度器的行为
package main

import (
	"fmt"
	"runtime"
	"sync"
)

// main是所有Go程序的入口
func main() {
	// 分配一个逻辑处理器给调度器使用
	runtime.GOMAXPROCS(1)

	// wg用来等待程序完成
	// 计数加2，表示要等待两个goroutine
	var wg sync.WaitGroup
	wg.Add(2)

	fmt.Println("Start Goroutines")

	// 声明一个匿名函数，并创建一个goroutine
	go func() {
		// 在函数退出时调用Done来通知main函数工作已经完成
		defer wg.Done()

		// 显示字母表3次
		for count := 0; count < 3; count++ {
			for char := 'a'; char < 'a'+26; char++ {
				fmt.Printf("%c ", char)
			}
		}
	}()

	// 声明一个匿名函数，并创建一个goroutine
	go func() {
		// 在函数退出时调用Done来通知main函数工作已经完成
		defer wg.Done()

		// 显示字母表3次
		for count := 0; count < 3; count++ {
			for char := 'A'; char < 'A'+26; char++ {
				fmt.Printf("%c ", char)
			}
		}
	}()

	// 等待goroutine结束
	fmt.Println("Waiting To Finish")
	wg.Wait()

	fmt.Println("\nTerminating Program")
}

这里两个匿名函数分别输出26个小写和大写字母，使用wait等待返回后，逻辑调度器停止，运行结果是
在这里插入图片描述
这里由于一个goroutine执行的太快，还没切换到第二个goroutine就已经全部输出完了
其中waitgroup是指两个运行的goroutine，done是通知执行完毕，这样做是防止一个routine执行太久，可以手动停止
如下是一个长时间运行的go示例，可以观察这一现象

// 这个示例程序展示goroutine调度器是如何在单个线程上
// 切分时间片的
package main

import (
	"fmt"
	"runtime"
	"sync"
)

// wg用来等待程序完成
var wg sync.WaitGroup

// main是所有Go程序的入口
func main() {

	// 分配一个逻辑处理器给调度器使用

	runtime.GOMAXPROCS(1)

	// 计数加2，表示要等待两个goroutine
	wg.Add(2)
	// 创建两个goroutine
	fmt.Println("Create Goroutines")
	go printPrime("A")
	go printPrime("B")
	// 等待goroutine结束
	fmt.Println("Waiting To Finish")
	wg.Wait()
	fmt.Println("Terminating Program")
}

// printPrime 显示5000以内的素数值
func printPrime(prefix string) {
	// 在函数退出时调用Done来通知main函数工作已经完成
	defer wg.Done()
next:
	for outer := 2; outer < 5000; outer++ {
		for inner := 2; inner < outer; inner++ {
			if outer%inner == 0 {
				continue next
			}
		}
		fmt.Printf("%s:%d\n", prefix, outer)
	}
	fmt.Println("Completed", prefix)
}

在这里插入图片描述
在这里插入图片描述
这里goroutine A先查找素数，耗时较长，这里调度器会调度到B，B输出4591时，又被调度器切换到A，然后A输出到4567，又切换到B，这次B输出完之后，线程接收到返回就切换回A并输出完剩下的数
这里import “runtime”
// 给每个可用的核心分配一个逻辑处理器，runtime.GOMAXPROCS(runtime.NumCPU()) ，runtime.NumCPU返回物理cpu的数量

package main

import (
	"fmt"
	"runtime"
	"sync"
)

// main是所有Go程序的入口
func main() {
	// 分配2个逻辑处理器给调度器使用
	runtime.GOMAXPROCS(2)

	// wg用来等待程序完成
	// 计数加2，表示要等待两个goroutine
	var wg sync.WaitGroup
	wg.Add(2)

	fmt.Println("Start Goroutines")

	// 声明一个匿名函数，并创建一个goroutine
	go func() {
		// 在函数退出时调用Done来通知main函数工作已经完成
		defer wg.Done()

		// 显示字母表3次
		for count := 0; count < 3; count++ {
			for char := 'a'; char < 'a'+26; char++ {
				fmt.Printf("%c ", char)
			}
		}
	}()
	// 声明一个匿名函数，并创建一个goroutine
	go func() {
		// 在函数退出时调用Done来通知main函数工作已经完成
		defer wg.Done()

		// 显示字母表3次
		for count := 0; count < 3; count++ {
			for char := 'A'; char < 'A'+26; char++ {
				fmt.Printf("%c ", char)
			}
		}
	}()

	// 等待goroutine结束
	fmt.Println("Waiting To Finish")
	wg.Wait()

	fmt.Println("\nTerminating Program")
}

在这里插入图片描述
只有在有多个逻辑处理器且可以同时让每个goroutine运行在一个可用的物理处理器上的时候，goroutine才会并行运行。

竞争状态

并行中，两个多个goroutine访问一个资源，并且没有互相同步，这就是竞争状态，通常这种读写必须是原子化的，即只有一个goroutine同时操作

// 这个示例程序展示如何在程序里造成竞争状态
// 实际上不希望出现这种情况
package main

import (
	"fmt"
	"runtime"
	"sync"
)

var (
	// counter是所有goroutine都要增加其值的变量
	counter int

	// wg用来等待程序结束
	wg sync.WaitGroup
)

// main是所有Go程序的入口
func main() {

	// 计数加2，表示要等待两个goroutine
	wg.Add(2)
	// 创建两个goroutine
	go incCounter(1)
	go incCounter(2)
	// 等待goroutine结束
	wg.Wait()
	fmt.Println("Final Counter:", counter)

}

// incCounter增加包里counter变量的值
func incCounter(id int) {
	// 在函数退出时调用Done来通知main函数工作已经完成
	defer wg.Done()
	for count := 0; count < 2; count++ {
		// 捕获counter的值
		value := counter
		// 当前goroutine从线程退出，并放回到队列
		runtime.Gosched()
		// 增加本地value变量的值
		value++
		// 将该值保存回counter
		counter = value
	}

}

在这里插入图片描述
如图，这个竞争状态下，两个goroutine值没有叠加，而是各自计算，互相覆盖，每个线程都会将值存到一个副本value中，然后再写入，goshed是将goroutine退出线程，让其他goroutine可以运行，便于观察
go语言有race工具可以用来观察竞争

go build -race   // 用竞争检测器标志来编译程序
./example  
// 运行程序 


================== 
WARNING: DATA RACE 
Write by goroutine 5: 
main.incCounter() 
/example/main.go:49 +0x96 
Previous read by goroutine 6: 
main.incCounter() 
/example/main.go:40 +0x66 
Goroutine 5 (running) created at: 
main.main() 
/example/main.go:25 +0x5c 
Goroutine 6 (running) created at: 
main.main() 
/example/main.go:26 +0x73 
================== 
Final Counter: 2 
Found 1 data race(s)

上一部分指出了有竞争状态的代码，分别是读写counter操作，可以通过锁来解决竞争问题

锁与原子函数

原子函数通过底层原理来规定访问资源的顺序

package main

import (
	"fmt"
	"runtime"
	"sync"
	"sync/atomic"
)

var (
	// counter是所有goroutine都要增加其值的变量
	counter int64

	// wg用来等待程序结束
	wg sync.WaitGroup
)

// main是所有Go程序的入口
func main() {
	// 计数加2，表示要等待两个goroutine
	wg.Add(2)
	// 创建两个goroutine
	go incCounter(1)
	go incCounter(2)
	// 等待goroutine结束
	wg.Wait()
	// 显示最终的值
	fmt.Println("Final Counter:", counter)
}

// incCounter增加包里counter变量的值
func incCounter(id int) {
	// 在函数退出时调用Done来通知main函数工作已经完成
	defer wg.Done()

	for count := 0; count < 2; count++ {
		// 安全地对counter加1
		atomic.AddInt64(&counter, 1)

		// 当前goroutine从线程退出，并放回到队列
		runtime.Gosched()
	}
}

在这里插入图片描述
这里使用atomic包下的addint64函数，保证同一时刻只有一个goroutine操作，并且它引用原子函数时，goroutine自动做同步，此外还有loadInt64和StoreInt64，分别时安全读写整型值， 并且创建一个同步标志并向不同goroutine通知

// 这个示例程序展示如何使用atomic包里的
// Store和Load类函数来提供对数值类型
// 的安全访问
package main

import (
	"fmt"
	"sync"
	"sync/atomic"
	"time"
)

var (
	// shutdown是通知正在执行的goroutine停止工作的标志
	shutdown int64

	// wg用来等待程序结束
	wg sync.WaitGroup
)

// main是所有Go程序的入口
func main() {
	// 计数加2，表示要等待两个goroutine
	wg.Add(2)

	// 创建两个goroutine
	go doWork("A")
	go doWork("B")

	// 给定goroutine执行的时间
	time.Sleep(1 * time.Second)

	// 该停止工作了，安全地设置shutdown标志
	fmt.Println("Shutdown Now")
	atomic.StoreInt64(&shutdown, 1)

	// 等待goroutine结束
	wg.Wait()

}

// doWork用来模拟执行工作的goroutine，
// 检测之前的shutdown标志来决定是否提前终止
func doWork(name string) {
	defer wg.Done()
	for {
		fmt.Printf("Doing %s Work\n", name)
		time.Sleep(250 * time.Millisecond)
		// 要停止工作了吗？
		if atomic.LoadInt64(&shutdown) == 1 {
			fmt.Printf("Shutting %s Down\n", name)
			break
		}
	}
}

// 在函数退出时调用Done来通知main函数工作已经完成

这里如果有goroutine试图在storeint时loadint，则原子函数会将其同步，保证其不进入竞争状态

互斥锁
// 这个示例程序展示如何使用互斥锁来
// 定义一段需要同步访问的代码临界区
// 资源的同步访问
package main

import (
	"fmt"
	"runtime"
	"sync"
)

var (
	// counter是所有goroutine都要增加其值的变量
	counter int

	// wg用来等待程序结束
	wg sync.WaitGroup

	// mutex 用来定义一段代码临界区
	mutex sync.Mutex
)

// main是所有Go程序的入口
func main() {
	// 计数加2，表示要等待两个goroutine
	wg.Add(2)

	// 创建两个goroutine
	go incCounter(1)
	go incCounter(2)

	// 等待goroutine结束
	wg.Wait()
	fmt.Printf("Final Counter: %d\\n", counter)
}

// incCounter使用互斥锁来同步并保证安全访问，
// 增加包里counter变量的值
func incCounter(id int) {
	// 在函数退出时调用Done来通知main函数工作已经完成
	defer wg.Done()

	for count := 0; count < 2; count++ {
		// 同一时刻只允许一个goroutine进入
		// 这个临界区
		mutex.Lock()
		{
			// 捕获counter的值
			value := counter

			// 当前goroutine从线程退出，并放回到队列
			runtime.Gosched()

			// 增加本地value变量的值
			value++

			// 将该值保存回counter
			counter = value
		}
		mutex.Unlock()
		// 释放锁，允许其他正在等待的goroutine
		// 进入临界区
	}
}

互斥锁就是定义一段临时区域，在解锁前只能有一个goroutine运行

通道

原子函数和互斥锁都是传统的解决办法，通道机制则是golang独有的解决办法，可以在goroutine中共享和交换数据

// 无缓冲的整型通道 
unbuffered := make(chan int) 
// 有缓冲的字符串通道 
buffered := make(chan string, 10)

分别创建了无缓冲和有缓冲的通道，chan关键字是必须的，之后是交换的数据类型，数字是缓冲区的大小

// 有缓冲的字符串通道 
buffered := make(chan string, 10) 
// 通过通道发送一个字符串 
buffered <- "Gopher"

如上是使用< -关键字向缓冲区发送字符串

// 从通道接收一个字符串 
value := <-buffered

如上是接收字符串，注意箭头方向

有无缓冲通道

无缓冲的通道是指没有保存能力的通道，发送和接收方需要同时准备好，如图
在这里插入图片描述
在通道中，2345步，两个goroutine都是被锁住的

// 这个示例程序展示如何用无缓冲的通道来模拟
// 2个goroutine间的网球比赛
package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

// wg用来等待程序结束
var wg sync.WaitGroup

func init() {
	rand.Seed(time.Now().UnixNano())
}

// main是所有Go程序的入口
func main() {
	// 创建一个无缓冲的通道
	court := make(chan int)

	// 计数加2，表示要等待两个goroutine
	wg.Add(2)

	// 启动两个选手
	go player("Nadal", court)
	go player("Djokovic", court)

	// 发球
	court <- 1

	// 等待游戏结束
	wg.Wait()

}

// player 模拟一个选手在打网球
func player(name string, court chan int) {

	// 在函数退出时调用Done来通知main函数工作已经完成
	defer wg.Done()
	for {
		// 等待球被击打过来
		ball, ok := <-court
		if !ok {
			// 如果通道被关闭，我们就赢了
			fmt.Printf("Player %s Won\n", name)
			return
		}
		// 选随机数，然后用这个数来判断我们是否丢球
		n := rand.Intn(100)
		if n%13 == 0 {
			fmt.Printf("Player %s Missed\n", name)
			// 关闭通道，表示我们输了
			close(court)
			return
		}
		// 显示击球数，并将击球数加1
		fmt.Printf("Player %s Hit %d\n", name, ball)
		ball++
		// 将球打向对手
		court <- ball
	}
}

在这里插入图片描述
如图，是一个击球的程序，模拟无缓冲的通道，在击球前等待通道传递数据，每次随机一个数字代表是否得分，得分则传递给通道，否则判定失败，无限循环

// 这个示例程序展示如何用无缓冲的通道来模拟
// 4个goroutine间的接力比赛
package main

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

// wg用来等待程序结束
var wg sync.WaitGroup

// main是所有Go程序的入口
func main() {
	// 创建一个无缓冲的通道
	baton := make(chan int)

	// 为最后一位跑步者将计数加1
	wg.Add(1)

	// 第一位跑步者持有接力棒
	go Runner(baton)

	// 开始比赛
	baton <- 1

	// 等待比赛结束
	wg.Wait()
}

// Runner模拟接力比赛中的一位跑步者
func Runner(baton chan int) {
	var newRunner int

	// 等待接力棒
	runner := <-baton
	// 开始绕着跑道跑步
	fmt.Printf("Runner %d Running With Baton\n", runner)
	// 创建下一位跑步者
	if runner != 4 {
		newRunner = runner + 1
		fmt.Printf("Runner %d To The Line\n", newRunner)
		go Runner(baton)
	}
	// 围绕跑道跑
	time.Sleep(100 * time.Millisecond)
	// 比赛结束了吗？
	if runner == 4 {
		fmt.Printf("Runner %d Finished, Race Over\n", runner)
		wg.Done()
		return
	}
	// 将接力棒交给下一位跑步者
	fmt.Printf("Runner %d Exchange With Runner %d\n",
		runner,
		newRunner)
	baton <- newRunner

}

如上是一个模拟接力的程序，开始等待通道传递数据，在几秒后给通道传入数据，知道第四个人，结束循环
这些是无缓冲的通道，必须即放即取，而有缓冲的通道如下，可以异步存取
在这里插入图片描述

// 这个示例程序展示如何使用
// 有缓冲的通道和固定数目的
// goroutine来处理一堆工作
package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

const (
	numberGoroutines = 4  // 要使用的goroutine的数量
	taskLoad         = 10 // 要处理的工作的数量
)

// wg用来等待程序完成
var wg sync.WaitGroup

// init初始化包，Go语言运行时会在其他代码执行之前
// 优先执行这个函数
func init() {
	// 初始化随机数种子
	rand.Seed(time.Now().Unix())
}

// main是所有Go程序的入口
func main() {
	// 创建一个有缓冲的通道来管理工作
	tasks := make(chan string, taskLoad)

	// 启动goroutine来处理工作
	wg.Add(numberGoroutines)
	for gr := 1; gr <= numberGoroutines; gr++ {
		go worker(tasks, gr)
	}

	// 增加一组要完成的工作
	for post := 1; post <= taskLoad; post++ {
		tasks <- fmt.Sprintf("Task : %d", post)
	}

	// 当所有工作都处理完时关闭通道
	// 以便所有goroutine退出
	close(tasks)

	// 等待所有工作完成
	wg.Wait()
	// 通知函数已经返回
	defer wg.Done()
}

// worker作为goroutine启动来处理
// 从有缓冲的通道传入的工作
func worker(tasks chan string, worker int) {
	for {
		// 等待分配工作
		task, ok := <-tasks
		if !ok {
			// 这意味着通道已经空了，并且已被关闭
			fmt.Printf("Worker: %d : Shutting Down\n", worker)
			return
		}
		// 显示我们开始工作了
		fmt.Printf("Worker: %d : Started %s\n", worker, task)
		// 随机等一段时间来模拟工作
		sleep := rand.Int63n(100)
		time.Sleep(time.Duration(sleep) * time.Millisecond)
		// 显示我们完成了工作
		fmt.Printf("Worker: %d : Completed %s\n", worker, task)
	}
}

运行结果
在这里插入图片描述
这里创建了四个goroutine代表四个人，10个任务，然后使用有缓冲的通道接收10个任务，之后通道会关闭，代表可以发送但不能接收，然后四个goroutine取出任务，直到从通道中接收不到任务，程序终止
有缓冲和无缓冲的最大区别就是是否保证goroutine同时处理任务

JoshuaGraham
关注
Go语言并发详解
qq_41854911的博客
11-09 8103
文章目录一、Go语言并发简述（并发的优势）进程/线程并发/并行协程/线程Goroutine 介绍channel二、Go语言goroutine（轻量级线程）使用普通函数创建 goroutine1) 格式2) 例子使用匿名函数创建goroutine1) 使用匿名函数创建goroutine的格式2) 使用匿名函数创建goroutine的例子提示三、Go语言并发通信四、Go语言竞争状态简述Goroutine 7 (finished) created at: main.main() D:/code/src/m
Go并发编程
上山的人
05-07 1904
并发介绍 进程和线程 A. 进程是程序在操作系统中的一次执行过程，系统进行资源分配和调度的一个独立单位。 B. 线程是进程的一个执行实体，是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。 C.一个进程可以创建和撤销多个线程；同一个进程中的多个线程之间可以并发执行。 协程和线程 协程：独立的栈空间，共享堆空间，调度由用户自己控制，本质上有点类似于用户级线程，这些用户级线程的调度也是自己实现的。线程：一个线程上可以跑多个协程，协程是轻量级的线程...
Golang通道（chan，协程交互数据）
墨痕诉清风的博客
02-11 3232
通道（channel）是用来传递数据的一个数据结构。通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。操作符
【Go语言从入门到实战】并发篇
How many ten years in the life time?
05-28 1418
并发篇：协程、共享内存并发机制、CSP并发机制（Channel）、多路选择和超时控制、channel的关闭和广播、任务的取消、Context、并发任务（单例模式、仅需任意任务完成、所有任务完成、对象池、sync.Pool 对象缓存） 另外还有单元测试的内容。
一看就明白的Go语言并发教程
ITVeni的博客
09-03 181
Go语言提供了强大的并发编程能力，通过Goroutines、Channels和互斥锁等机制，使得并发编程变得简单和高效。本文将使用通俗的语言和简单的案例讲述Go语言并发编程的那些事儿。
5.Go语言高并发与微服务实战 --- 构建 Go Web 服务器
enlyhua的专栏
10-15 485
【代码】5.Go语言高并发与微服务实战 --- 构建 Go Web 服务器。
2.Go语言高并发与微服务实战 --- 微服务概述
enlyhua的专栏
09-30 318
【代码】2.Go语言高并发与微服务实战 --- 微服务概述。
GoLang-从入门到实战-经典教程
最新发布
09-05
第6章 更多的类型 第7章 指针、结构体和方法 第8章 接口 第9章 并发 第10章 面向对象编程 第11章 延迟和错误处理 --------实战------ Golang并发模型：轻松入门流水线模型 Golang并发模型：轻松入门流水线FAN模式 ...
桫哥-GOlang基础-Go语言实战：驾考系统
06-12
《Go语言实战：驾考系统》是一门针对Go语言初学者和进阶者的教程，旨在帮助学习者从零开始，逐步掌握Go语言的基础语法，并通过实战案例深化理解，提升编程能力。课程风格轻松活泼，注重理论与实践的结合，鼓励创新...
重磅！《Go Web编程实战派从入门到精通》随书源码开源啦，Go语言-Web-goWebActualCombat.zip
11-06
《Go Web编程实战派从入门到精通》是一本专注于Go语言在Web开发领域的专著，其开源的随书源码库名为"Go语言-Web-goWebActualCombat"，压缩包内的主要内容是goWebActualCombat-master目录，这代表了一个完整的Go语言...
Go并发编程详解
金戈鐡馬
12-04 1364
随着硬件的发展，并发程序变得越来越重要。Web服务器会一次处理成千上万的请求。平板电脑和手机app在渲染用户画面同时还会后台执行各种计算任务和网络请求。即使是传统的批处理问题--读取数据，计算，写输出--现在也会用并发来隐藏掉I/O的操作延迟以充分利用现代计算机设备的多个核心。计算机的性能每年都在以非线性的速度增长。
Go 语言精进之路——Go 中常见并发模式总结
奔跑的蜗牛的博客
06-30 909
本文主要总结了 Go 中使用 goroutine 和 channel 以及 select 实现的几种常用并发模式，包括优雅退出，取消超时，管道模式等。 附：封面图片在文章末尾哟~ 😊
Go语言并发Goroutine
wang11876的博客
07-02 450
Go是并发语言，而不是并行语言。在讨论如何在Go中进行并发处理之前，我们首先必须了解什么是并发，以及它与并行性有什么不同。并发性Concurrency是同时处理许多事情的能力。举个例子，假设一个人在晨跑。在晨跑时，他的鞋带松了。现在这个人停止跑步，系鞋带，然后又开始跑步。这是一个典型的并发性示例。这个人能够同时处理跑步和系鞋带，这是一个人能够同时处理很多事情。什么是并行性parallelism，它与并发concurrency有什么不同?并行就是同时做很多事情。这听起来可能与并发类似，但实际上是不同的。
Go语言并发
Gavin
05-28 1030
此时main函数的Goroutine继续执行,如果helloworld()函数不能够在main函数的Goroutine执行完毕之前将任务处理完毕,那么就会发生helloworld()函数没有执行的样子;注意：使用go关键字创建协程时，被调用的函数往往没有返回值，如果函数有返回值，那么返回值会被忽略，那我们就是要返回值时，必须使用channel，通过channel把数据从中取出来；创建和启动主Goroutine，初始化操作，执行main函数，当main函数执行结束后，程序也就结束了；
Go并发介绍及其使用
二进制杯莫停的博客
02-16 695
当多个 goroutine 同时进行处理的时候，就会遇到比如同时抢占一个资源，某个 goroutine 等待另一个 goroutine 处理完某一个步骤之后才能继续的需求。在 golang 的官方文档上，作者明确指出，golang 并不希望依靠共享内存的方式进行进程的协同操作。而是希望通过管道 channel 的方式进行。当然，golang 也提供了共享内存，锁，等机制进行协同操作的包。sync 包就是为了这个目的而出现的。
Go 中有效并发的模式
csjds的专栏
12-28 740
在本文中，我们将深入探讨 Go 中有效并发的五个基本模式：理解并行性和并发性的区别、任务分解的概念、工作池的实用性、取消和上下文，以及测试并发代码。
Go语言的并发模型与sync.Pool与sync.Once
程序员光剑
01-18 909
1.背景介绍 Go语言的并发模型是Go语言中的一个重要特性，它使得Go语言能够充分发挥多核处理器的优势，提高程序的性能。sync.Pool和sync.Once是Go语言中的两个内置的同步原语，它们 respective地用于实现对共享资源的安全访问和确保代码只执行一次的功能。 在本文中，我们将深入探讨Go语言的并发模型，以及sync.Pool和sync.Once的核心概念、算法原理和具体操作步...
Go 并发编程
qq_46457076的博客
01-17 1140
关于 Go 语言之高性能并发编程的基础知识！
Go的并发
Harris-H的博客
12-18 1210
Go的并发 1.并发 https://docs.microsoft.com/zh-cn/learn/modules/go-concurrency/1-goroutines Goroutine goroutine 是轻量线程中的并发活动，而不是在操作系统中进行的传统活动。 假设你有一个写入输出的程序和另一个计算两个数字相加的函数。 一个并发程序可以有数个 goroutine 同时调用这两个函数。 我们可以说，程序执行的第一个 goroutine 是 main() 函数。 如果要创建其他 goroutine，则
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值