go并发模式

已于 2022-03-14 23:08:36 修改
阅读量554 收藏 1
点赞数 1
分类专栏： Go学习 文章标签： golang 开发语言 后端
于 2022-03-14 23:07:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43135259/article/details/123487186
版权

所谓的并发模式并不像设计模式一样是一个普遍的标准,只是前人总结出的经验

生成器

package main

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

func msgGen(serviceName string) chan string {
	c := make(chan string)
	go func() {
		i := 0
		for {
			time.Sleep(time.Duration(rand.Intn(2000)) * time.Millisecond)
			c <- fmt.Sprintf("%s message: %d", serviceName, i)
			i++
		}
	}()
	return c
}

func main() {
	m1 := msgGen("service1")
	m2 := msgGen("service2")
	for {
		fmt.Println(<-m1)
		fmt.Println(<-m2)
	}
}

在这里插入图片描述
生成器其实就是服务/任务;利用chan来与对应服务去进行交互;再msgGen函数里面一直给两个chan发送数据;main函数里面一直再收两个chan的数据;但是两个chan的消息是交替消费的;必须要等接收到m1时再去接收m2,并不是同时的等待m1和m2;这个不是理想的效果

添加中间节点

在这里插入图片描述
我们通过添加一个中间节点,把两个chan的数据统一收上来,然后再发到中间节点上,我们main函数里面只负责去接收中间节点的消息,达到我们同时等待m1和m2数据的目的

package main

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

func msgGen(serviceName string) chan string {
	c := make(chan string)
	go func() {
		i := 0
		for {
			time.Sleep(time.Duration(rand.Intn(2000)) * time.Millisecond)
			c <- fmt.Sprintf("%s message: %d", serviceName, i)
			i++
		}
	}()
	return c
}

func fanIn(m1, m2 chan string) chan string {
	c := make(chan string)
	go func() {
		for {
			c <- <-m1
		}
	}()
	go func() {
		for {
			c <- <-m2
		}
	}()
	return c
}

func main() {
	m1 := msgGen("service1")
	m2 := msgGen("service2")
	m := fanIn(m1, m2)
	for {
		fmt.Println(<-m)
	}
}

在这里插入图片描述

Select实现

package main

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

func msgGen(serviceName string) chan string {
	c := make(chan string)
	go func() {
		i := 0
		for {
			time.Sleep(time.Duration(rand.Intn(2000)) * time.Millisecond)
			c <- fmt.Sprintf("%s message: %d", serviceName, i)
			i++
		}
	}()
	return c
}

func fanIn(m1, m2 chan string) chan string {
	c := make(chan string)
	go func() {
		for {
			c <- <-m1
		}
	}()
	go func() {
		for {
			c <- <-m2
		}
	}()
	return c
}

func fanIntBySelect(m1, m2 chan string) chan string {
	c := make(chan string)
	go func() {
		for {
			select {
			case m := <-m1:
				c <- m
			case m := <-m2:
				c <- m
			}
		}
	}()
	return c
}

func main() {
	m1 := msgGen("service1")
	m2 := msgGen("service2")
	m := fanIntBySelect(m1, m2)
	for {
		fmt.Println(<-m)
	}
}

在这里插入图片描述

中间节点 VS Select

  • Select

    • 写起来简单
    • 只开了一个协程(不管有多少chan都是一个协程)
    • 真正的做到了同时等待两个chan
    • 适合对chan数量不明确的场景下使用

  • 中间节点

    • 开了两个协程(有多少chan就要开多少协程)
    • 适合对chan数量明确的场景下使用

改造中间节点方式适用于chan数量不明确

package main

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

func msgGen(serviceName string) chan string {
	c := make(chan string)
	go func() {
		i := 0
		for {
			time.Sleep(time.Duration(rand.Intn(2000)) * time.Millisecond)
			c <- fmt.Sprintf("%s message: %d", serviceName, i)
			i++
		}
	}()
	return c
}

func fanIn(chans ...chan string) chan string {
	c := make(chan string)
	for _, ch := range chans {
		go func(ch chan string) {
			for {
				c <- <-ch
			}
		}(ch)
	}
	return c
}

func fanIntBySelect(m1, m2 chan string) chan string {
	c := make(chan string)
	go func() {
		for {
			select {
			case m := <-m1:
				c <- m
			case m := <-m2:
				c <- m
			}
		}
	}()
	return c
}

func main() {
	m1 := msgGen("service1")
	m2 := msgGen("service2")
	m := fanIn(m1, m2)
	for {
		fmt.Println(<-m)
	}
}

在这里插入图片描述
再fanIn函数里面必须要把最外层的循环里面的ch传到协程里面;不然再main函数里面就只会接收到最后一个chan的数据.具体原因是因为最外层的ch这个变量再全局只有一份,我们再循环里面创建协程的时候,只是把协程创建了,并不会马上的去执行协程里面的内容,等到遍历到最后一个chan的时候所有的协程里面都会改变成最后一个ch;所以就只会接收到最后一个chan的数据.但是我们把ch当成参数传入到协程里面就相当于把每个chan都copy了一份放到协程里面;就不会发生改变,也不会出现问题!

任务的控制

非阻塞等待

package main

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

func msgGen(serviceName string) chan string {
	c := make(chan string)
	go func() {
		i := 0
		for {
			time.Sleep(time.Duration(rand.Intn(2000)) * time.Millisecond)
			c <- fmt.Sprintf("%s message: %d", serviceName, i)
			i++
		}
	}()
	return c
}
func main() {
	m1 := msgGen("service1")
	m2 := msgGen("service2")
	for {
		fmt.Println(<-m1)
		select {
		case m := <-m2:
			fmt.Println(m)
		default:
			fmt.Println("no message from service2")
		}
	}
}

在这里插入图片描述

超时机制

package main

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

func msgGen(serviceName string) chan string {
	c := make(chan string)
	go func() {
		i := 0
		for {
			time.Sleep(time.Duration(rand.Intn(2000)) * time.Millisecond)
			c <- fmt.Sprintf("%s message: %d", serviceName, i)
			i++
		}
	}()
	return c
}

func main() {
	m1 := msgGen("service1")
	for {
		if m, ok := timeoutWait(m1, time.Second); ok {
			fmt.Println(m)
		} else {
			fmt.Println("timeout")
		}
	}
}

func timeoutWait(c chan string, timeout time.Duration) (string, bool) {
	select {
	case m := <-c:
		return m, true
	case <-time.After(timeout):
		return "", false
	}
}

在这里插入图片描述

任务中断/退出

package main

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

func msgGen(serviceName string) chan string {
	c := make(chan string)
	go func() {
		i := 0
		for {
			time.Sleep(time.Duration(rand.Intn(2000)) * time.Millisecond)
			c <- fmt.Sprintf("%s message: %d", serviceName, i)
			i++
		}
	}()
	return c
}

func main() {
	m1 := msgGen("service1")
	for i := 0; i < 5; i++ {
		if m, ok := timeoutWait(m1, time.Second); ok {
			fmt.Println(m)
		} else {
			fmt.Println("timeout")
		}
	}
}

func timeoutWait(c chan string, timeout time.Duration) (string, bool) {
	select {
	case m := <-c:
		return m, true
	case <-time.After(timeout):
		return "", false
	}
}

在这里插入图片描述
这里面的退出是main函数把循环都执行完了,不管其他的协程是否执行完毕,都会统一的杀死

优雅的退出

package main

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

func msgGen(serviceName string, done chan struct{}) chan string {
	c := make(chan string)
	go func() {
		i := 0
		for {
			select {
			case <-time.After(time.Duration(rand.Intn(2000)) * time.Millisecond):
				// 2秒内没有收到done才会去发送数据
				c <- fmt.Sprintf("%s message: %d", serviceName, i)
			case <-done:
				// 如果收到了done,直接优雅的退出
				fmt.Println("准备退出...")
				time.Sleep(2 * time.Second)
				done <- struct{}{}
				fmt.Println("准备完成")
				return
			}

			i++
		}
	}()
	return c
}

func main() {
	done := make(chan struct{})
	m1 := msgGen("service1", done)
	for i := 0; i < 5; i++ {
		if m, ok := timeoutWait(m1, time.Second); ok {
			fmt.Println(m)
		} else {
			fmt.Println("timeout")
		}
	}
	// main函数执行完毕通知其他协程退出
	done <- struct{}{}
	<-done
}

func timeoutWait(c chan string, timeout time.Duration) (string, bool) {
	select {
	case m := <-c:
		return m, true
	case <-time.After(timeout):
		return "", false
	}
}

在这里插入图片描述

通过done chan双向交互进行优雅的退出,实际的应用中不一定要重用done chan

.番茄炒蛋
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Go语言的并发模式
alvin_666的博客
09-22 390
Go语言的并发模式 1、约束 保证操作安全的方法： 用于共享内存的同步原语 （锁，sync.Mutex） 通过通信共享内存来进行同步（channel） 隐式并发安全： 不会发生改变的数据和受保护的数据 在并发编程中，不可变数据是理想的，它隐式的并行安全。 并发进程之间可以对相同的数据操作，但是不能修改，如果创建新数据，就需要创建所需修改的数据的新副本，可以提高开发效率和程序运行速度，使得程序临界...
几个go 并发模式
揽月御歌行
02-15 1323
go 语言中向一个已经关闭的channel发送数据会引起panic，因此go并发中一个基本的原则就是在数据发送端关闭channel。 虽然channel是双向的通道，两个go routine可以通过一个channel进行双向通信，但是在一般的数据流的模式下，我们宁可将channel降级为单向的通道，以获取更安全可读的代码。本文主要介绍一些将channel作为单向通信的并发模式，文末会简单给一个双向...
11 | 并发模式：Go 语言中即学即用的高效并发模式
剑心！的博客
03-21 292
11 | 并发模式：Go 语言中即学即用的高效并发模式 如何通过 Context 实现日志跟踪？ 要想跟踪一个用户的请求，必须有一个唯一的 ID 来标识这次请求调用了哪些函数、执行了哪些代码，然后通过这个唯一的 ID 把日志信息串联起来。这样就形成了一个日志轨迹，也就实现了用户的跟踪，于是思路就有了。 在用户请求的入口点生成 TraceID。 通过 context.WithValue 保存 TraceID。 然后这个保存着 TraceID 的 Context 就可以作为参数在各个协程或者函数间传
Go常见并发模式
Salted fish in hand, I have the world.
01-14 2584
文章目录一、Go语言并发的基础元素1.goroutine2.channel3.sync 包的同步原语4.多并发控制神器：Context二、常见并发模式Go语言实现1.for select 循环模式无限循环（监控狗）有限循环（for range select ）2.select timeout 模式3.流水线模式(Pipeline)4.扇出和扇入模式5.未来模式(Futures) 一、Go语言并发的基础元素 goroutine、channel、sync 是并发编程中必不可少的元素， context标准包更是为
Go 并发模型
魔筝炼药师
05-26 681
Go 语言中实现了两种并发模型，一种是依赖于共享内存实现的线程-锁并发模型，另一种则是CSP（Communicationing Sequential Processes，通信顺序进程）并发模型。 大多数编程语言（比如 C++、Java、Python 等）的并发逻辑都是基于操作系统的线程。并发执行单元（线程）之间的通信利用的就是操作系统提供的线程或进程间通信的原语，如共享内存、信号、管道、消息队列、套接字等。在这些通信原语中，使用最广泛的就是共享内存。 而 Go 语言从设计之初，就将解决上面传统并发模型问题
【go语言】Goroutines 并发模式（二）
weixin_34224941的博客
05-31 153
2019独角兽企业重金招聘Python工程师标准>>> ...
golang-concurrency-patterns:Go 并发模式
07-05
Go 语言中的并发模式可以用来设计这样的选举算法，例如使用通道和锁来实现。 10. ** Context**： `context` 包提供了一种取消信号、超时和截止日期的传递方式，特别适用于长生命周期的goroutines，如网络请求，当...
go 基础语法，go 并发模式，go runtime 实现原理 ，企业级 go 语言项目经验.zip
最新发布
02-28
Go 语言的基础语法、并发模式以及运行时实现原理是学习 Go 的核心部分。接下来，我们将深入探讨这些知识点。 一、Go 基础语法 1. **变量声明**：Go 语言支持 var、:= 和 type 关键字声明变量，其中 := 是 Go 的...
go-concurrency:Go并发模式示例
05-16
本项目"Go并发模式"提供了一系列示例，旨在帮助开发者理解Go语言中的并发概念和最佳实践。 1. Goroutines Goroutines是Go语言中轻量级的线程，由Go运行时管理。它们的开销非常小，可以轻易创建数千个。在Go代码中，...
go 后端程序员宝典：go基础语法，go底层原理，go runtime 实现原理，go 并发模式 ，go语言项目经验
11-21
go 后端程序员宝典：go基础语法，go底层原理，go runtime 实现原理，go 并发模式 ，go语言项目经验，包含go语言的基本语法、go语言高级用法、算法与数据结构。具体请见README.md，有详细目录。
【文件夹】Go语言并发之道.pdf
05-12
第3章 Go语言并发组件 47 goroutine 47 sync包 58 WaitGroup 58 互斥锁和读写锁 60 cond 64 once 69 池 71 channel 76 select 语句 92 GOMAXPROCS控制 97 小结 98 第4章 Go语言的并发模式 99 约束 99 for-select循环...
Go 并发编程模型
技术能量站
11-04 1175
Go 语言中实现了两种并发模型，一种是依赖于共享内存实现的线程-锁并发模型，另一种则是CSP（Communicationing Sequential Processes，通信顺序进程）并发模型。
Go语言的并发模型
qq_23587709的博客
08-13 382
​ 在现代的操作系统中，线程是CPU调度和分配的基本单位，而进程作为资源则是这些基本单位的拥有者。每一个进程都拥有一个主干线程，它由系统自动进行创建。用户可根据自己所需创建线程，多个线程可以并发的运行在同一个进程中。​ 无论语言层面何种并发模型，到了操作系统层面，一定是以线程的形态存在的。而操作系统根据资源访问权限的不同，体系架构可分为用户空间和内核空间；...
Golang常见的并发模式
weixin_33950035的博客
04-02 295
Go语言最吸引人的地方是它内建的并发支持。Go语言并发体系的理论是C.A.R Hoare在1978年提出的CSP（Communicating Sequential Process，通讯顺序进程）。CSP有着精确的数学模型，并实际应用在了Hoare参与设计的T9000通用计算机上。从NewSqueak、Alef、Limbo到现在的Go语言，对于对CSP有着20多年实战经验的Rob Pike来说，他更...
Go与并发模型
Linuxb的秘密花园
01-11 4274
最近，Google的Golang荣获2016年度编程语言，作为一个谷粉，我理应写一篇文章以表祝贺，正好碰上最近在弄一个支持IO无锁并发的脚本引擎，参考了一些Go内部的设计思想，真想不到Go的萌萌的外表下竟隐藏着一颗如此强大的内心，本文主要的分析焦点就是做到更干净的并发编程，让并发编程的代码更加优雅～
Go的并发
simatongming的博客
09-29 972
首先并行!=并发,并发是逻辑上的并行. 例如:多个程序在单核处理器上运行,每个程序只能在对应的时间片上运行,因为时间片很短,看起来就像是并行. 一.go语言级别的线程goroutine goroutine是Go语言中的轻量级线程实现.它是一个普通的函数,只需使用保留字 go 作为开头。 例如:两个goroutine打印1-10//这个程序是不会输出的,因为go还没执行完成,m
go并发
李坚强的博客
07-29 206
死锁,活锁,饥饿 饥饿：表示在任何情况下，并发进程都无法获得执行工作所需的所有资源 饥饿通常指一个或多个并发进程占有资源，使得其他进程不能占有资源进行执行 死锁—因争夺资源而造成的一种互相等待的现象，若无外力作用，他们讲无法推进下去。此时称系统处于死锁状态或者产生死锁，这些永远在互相等待的进程死锁进程。 示例(无缓存的channel,必须等待接受操作才放行) 活锁是正在主动执行并发操作的程序,但是这些操作无战向前 推进 程序的状 态。尽管不会阻塞线程，但也不能继续执行，因为线程不断重复同样的操作
Go 并发
qq_42250642的博客
12-29 667
Go 并发 二十二、并发 1、 1）主线程是一个物理线程，直接作用在cpu上，是重量级的，非常消耗cpu资源 2）协程从主线程开启，是轻量级的线程，是逻辑态，对资源消耗相对小 3）golang的协程机制是重要的特点，可以轻松开启上万个协程。其他编程语言的并发机制是一般基于线程的，开启过多的线程，资源耗费大，这就突显golang在并发上的优势了 2、goroutine 是轻量级线程（可以叫做协程） goroutine 的调度是由 Golang 运行时进行管理的 3、goroutine的调度模型：MPG模型 1
Go语言并发模式解析与实践
"《常见的并发模式-计算机组成原理-第二版-唐朔飞著-课后习题答案完整版》是唐朔飞所著的一本关于计算机组成原理和Go语言编程的书籍，书中深入探讨了并发编程中的常见模式。" 在Go语言中，并发是其核心特性之一，它...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

.番茄炒蛋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值