您当前的位置:首页 > 电脑百科 > 程序开发 > 语言 > Go语言

Go语言异步高并发编程的秘密:无锁,无条件变量,无回调

时间:2023-03-10 15:11:28  来源:今日头条  作者:研道鸠摩智


背景

在并发处理中,资源争用是一个常见的问题。为了避免资源争用,需要进行优化。以下是一些可以优化并发处理中的资源争用问题的建议:

  1. 避免锁竞争:锁竞争是一种常见的资源争用问题。可以通过减少锁的使用,使用更细粒度的锁,以及避免不必要的锁竞争来减少锁竞争。
  2. 使用缓存:在一些情况下,可以使用缓存来减少资源争用。例如,在处理一些计算密集型的任务时,可以使用缓存来避免重复计算。
  3. 使用原子操作:原子操作可以在不使用锁的情况下实现资源的同步访问。Go 语言中提供了一些原子操作,例如 atomic.AddInt32 和 atomic.LoadInt32 等,可以用于实现线程安全的资源访问。
  4. 使用互斥锁:互斥锁是一种用于避免并发资源争用的机制。在需要对资源进行访问的时候,可以使用互斥锁来保证资源的独占访问。
  5. 使用读写锁:读写锁是一种特殊的互斥锁,可以允许多个读操作同时进行,但是只允许一个写操作进行。在读操作频繁的场景下,可以使用读写锁来提高并发性能。
  6. 使用条件变量:条件变量是一种用于在不同线程之间进行协调的机制。可以使用条件变量来避免不必要的资源争用。例如,在一个生产者-消费者模式的程序中,可以使用条件变量来协调生产者和消费者之间的交互,从而避免资源争用

但是如果让你不用锁,条件变量,回调的话,还怎么写并发程序啊,谷歌大佬Sameer给了大家一个思路。"Advanced Go Concurrency Patterns" by Sameer Ajmani: 这篇博客深入研究了 Golang 中的并发模式,并讨论了如何使用它们来构建高性能系统。它仅仅使用了Go语言的goroutine和channel便实现高效异步并发编程,没有用到诸如await,context等包括锁,条件变量,和回调函数,文章包括一些示例和实践建议,帮助读者更好地理解和实践这些概念。下面我们针对他给出的case做一些说明与总结,同时对go语言并发编程的语言特性与技巧进行总结,换句话就是说想提炼出面向场景的go语言高并发编程的八股模式

select-loop的编程关键要素

1.如何处理事件

2.如何处理元素

3.如何关闭退出

代码示例

 

核心结构与接口

下面代码给出了核心结构sub,以及它实现了接口subscription的关键代码。

  1. updates属性是一个通道,用于用户对元素进行处理。
  2. fetcher是用于获取元素的客户端,它可以是从数据库读取,也可以是从消息队列读取。
  3. closing用于关闭退出select-loop主体

// sub implements the Subscription interface.
type sub struct {
	fetcher Fetcher         // fetches items
	updates chan Item       // sends items to the user
	closing chan chan error // for Close
}

func (s *sub) Updates() <-chan Item {
	return s.updates
}

func (s *sub) Close() error {
	errc := make(chan error)
	s.closing <- errc // 向closing通道中同步写入errc
	return <-errc     // 等待主loop返回
}

// Subscribe returns a new Subscription that uses fetcher to fetch Items.
func Subscribe(fetcher Fetcher) Subscription {
	s := &sub{
		fetcher: fetcher,
		updates: make(chan Item),       // for Updates
		closing: make(chan chan error), // for Close
	}
	go s.loop()
	return s
}

sub的核心处理逻辑

// loop periodically fecthes Items, sends them on s.updates, and exits
// when Close is called.  It extends dedupeLoop with logic to run
// Fetch asynchronously.
func (s *sub) loop() {
	const maxPending = 10
	type fetchResult struct {
		fetched []Item
		next    time.Time
		err     error
	}
	var fetchDone chan fetchResult // if non-nil, Fetch is running
	var pending []Item
	var next time.Time
	var err error
	var seen = make(map[string]bool)
	for {
		var fetchDelay time.Duration
		if now := time.Now(); next.After(now) {
			fetchDelay = next.Sub(now)
		}
		var startFetch <-chan time.Time
		if fetchDone == nil && len(pending) < maxPending { 
      //等待队列长度未超过最大设置且fetchDone是空,即元素已经都入队列了
      // 设置fetchDelay时间后,startFetch通道有值
			startFetch = time.After(fetchDelay) 
		}
		var first Item
		var updates chan Item
		if len(pending) > 0 {
			first = pending[0]
			updates = s.updates // updates通道是为了用户进一步消费的
		}
		select {
		case <-startFetch:
			fetchDone = make(chan fetchResult, 1)
			go func() {
				fetched, next, err := s.fetcher.Fetch()
				fetchDone <- fetchResult{fetched, next, err}
			}()
		case result := <-fetchDone:
			fetchDone = nil
			// Use result.fetched, result.next, result.err
			fetched := result.fetched
			next, err = result.next, result.err
			if err != nil {
				next = time.Now().Add(10 * time.Second)
				break
			}
			for _, item := range fetched {
				if id := item.GUID; !seen[id] {
					pending = Append(pending, item)
					seen[id] = true
				}
			}
		case errc := <-s.closing:
			errc <- err
			close(s.updates)
			return
		case updates <- first:
			pending = pending[1:]
		}
	}
}

那么上面的代码是如何处理三个关键问题的呢?

  • 首先关于关闭并退出loop

上述代码通过监听sub结构的closing属性,实现退出。

//Close asks loop to exit and waits for a response.
func (s *sub) Close() error {
    errc := make(chan error)
    s.closing <- errc
    return <-errc
}

当调用sub的Close方法时,s.closing会接收一个errc的通道,loop主体向errc中写入error信息并退出,调用sub的Close方法的客户端从errc中也同步收到error信息。这是一个同步关闭的过程。loop主体可以在给客户端发送error信息之前,可以完成一系列的关闭清理工作。

  • 关于事件处理与调度

程序中设置的下一次获取元素的延迟调度的最小单位是10秒,从下面第22行可以看到,如果获取元素很快,没有耗费10秒,那么fetchDelay便有个时间gap,startFetch(第7行)这个时间通道便会通过time.After这个方法,在fetchDelay时间后,收到信号,完成18到25行的获取元素工作。

    var pending []Item // appended by fetch; consumed by send
    var next time.Time // initially January 1, year 0
    var err error
    for {
        var fetchDelay time.Duration // initially 0 (no delay)
        if now := time.Now(); next.After(now) {
            fetchDelay = next.Sub(now)
        }
        startFetch := time.After(fetchDelay)

     select {
        case <-startFetch:
            var fetched []Item
            fetched, next, err = s.fetcher.Fetch()
            if err != nil {
                next = time.Now().Add(10 * time.Second)
                break
            }
            pending = append(pending, fetched...)
       
        }
    }

问题:为了防止等待队列过大,所以只有当长度不超过maxPending,并且获取的数据已经入队了的时候,才会设置startFetch,否则就不触发fetch。这块可以结合上面整个代码看看

        var fetchDelay time.Duration
        if now := time.Now(); next.After(now) {
            fetchDelay = next.Sub(now)
        }
        var startFetch <-chan time.Time
        if fetchDone == nil && len(pending) < maxPending {
            startFetch = time.After(fetchDelay) // enable fetch case
        }

问题: Loop blocks on Fetch.

golang有个特性,就是Sends and receives on nil channels block.利用这个特性,当fetchDone是nil或者他里面没有准备好结果的时候,相关的case都会阻塞,那么select也不会选择它。同时为了防止fetch函数阻塞loop主函数,通过启动协程(下面9-12行),再次提升主loop的性能。

type fetchResult struct{ fetched []Item; next time.Time; err error }
var fetchDone chan fetchResult // if non-nil, Fetch is running
var startFetch <-chan time.Time
        if fetchDone == nil && len(pending) < maxPending {
            startFetch = time.After(fetchDelay) // enable fetch case
        }
select {
        case <-startFetch:
            fetchDone = make(chan fetchResult, 1)
            go func() {
                fetched, next, err := s.fetcher.Fetch()
                fetchDone <- fetchResult{fetched, next, err}
            }()
        case result := <-fetchDone:
            fetchDone = nil
            // Use result.fetched, result.next, result.err

总结

上面用到了3个技巧,如下所示:

  • for-select loop
  • service channel, reply channels (chan chan error)
  • nil channels in select cases

通过err,next,pending三个变量,就实现了在没有锁,条件变量,回调情况下,编写高效并发go程序的需求

参考文献:

https://go.dev/talks/2013/advconc.slide#43



Tags:Go   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,如有任何标注错误或版权侵犯请与我们联系(Email:2595517585@qq.com),我们将及时更正、删除,谢谢。
▌相关推荐
背景一谈到golang,大家的第一感觉就是高并发,高性能。但是语言本身的优势是不是,就让程序员觉得编写高性能的处理系统变得轻而易举,水到渠成呢。下面这篇文章给大家的提醒便是,...【详细内容】
2023-03-13  Tags: Go  点击:(1)  评论:(0)  加入收藏
在日常开发中,经常会遇到在程序中获取路径的问题。相信很多同学被这个问题搞得头痛不已,可能也没有深入思考过这个问题,在网上搜到相关代码就稀里糊涂得使用了,也没有在不同的...【详细内容】
2023-03-13  Tags: Go  点击:(1)  评论:(0)  加入收藏
背景在并发处理中,资源争用是一个常见的问题。为了避免资源争用,需要进行优化。以下是一些可以优化并发处理中的资源争用问题的建议: 避免锁竞争:锁竞争是一种常见的资源争用问...【详细内容】
2023-03-10  Tags: Go  点击:(0)  评论:(0)  加入收藏
在计算机刚被发明的初期,那时还没有互联网,更不用提IDE、丰富的在线文档、Google以及Stack Overflow,那时的程序员是怎样编程的呢?前几天看恰好看了国外老哥一篇很有意思的文章...【详细内容】
2023-03-09  Tags: Go  点击:(7)  评论:(0)  加入收藏
上篇文章介绍了Mongo读取数据的策略(​​MongoDB读数据策略​​),主要是readconcern、readpreference两参数,其中readconcern作用于服务端,决定了什么时候能读取到数据;readprefer...【详细内容】
2023-03-09  Tags: Go  点击:(6)  评论:(0)  加入收藏
本文我们介绍怎么使用命令行工具 micro new 创建一个 gRPC 服务,并且怎么构建和运行服务。​01 介绍Go 开源项目 Micro​ 为我们提供一套微服务解决方案,它主要包含两个部分...【详细内容】
2023-03-06  Tags: Go  点击:(6)  评论:(0)  加入收藏
出品 | OSC开源社区(ID:oschina2013)在线学习平台 O&#39;Reilly 最新发布了 2023 年度技术趋势报告,基于该平台 280 万的用户数据,以了解开发人员的兴趣所在。调查结果表明,开发...【详细内容】
2023-03-05  Tags: Go  点击:(11)  评论:(0)  加入收藏
Go 为了自身 goroutine 执行和调度的效率,自身在 runtime 中实现了一套 goroutine 的调度器。 写在前面Go 为了自身 goroutine 执行和调度的效率,自身在 runtime 中实现了一...【详细内容】
2023-03-03  Tags: Go  点击:(6)  评论:(0)  加入收藏
不懂的小伙伴继续听我娓娓道来!首先准备工作,需要用到的软件:软件:1、电脑(开网页不卡的就行)2、ti子3、谷歌浏览器(多开方便些,别的也可以)4、桌面令牌5、选品软件6、利润计算公式分...【详细内容】
2023-02-27  Tags: Go  点击:(17)  评论:(0)  加入收藏
本文我们介绍了跨平台文件监听库 fsnotify,它主要用于自动监听文件中的内容变更。我们通过 fsnotify 源码和示例代码,介绍了该库支持的功能和使用方式。​1、介绍Go 语言作为...【详细内容】
2023-02-26  Tags: Go  点击:(10)  评论:(0)  加入收藏
▌简易百科推荐
背景一谈到golang,大家的第一感觉就是高并发,高性能。但是语言本身的优势是不是,就让程序员觉得编写高性能的处理系统变得轻而易举,水到渠成呢。下面这篇文章给大家的提醒便是,...【详细内容】
2023-03-13  研道鸠摩智  今日头条  Tags:Golang   点击:(1)  评论:(0)  加入收藏
在日常开发中,经常会遇到在程序中获取路径的问题。相信很多同学被这个问题搞得头痛不已,可能也没有深入思考过这个问题,在网上搜到相关代码就稀里糊涂得使用了,也没有在不同的...【详细内容】
2023-03-13  路多辛  今日头条  Tags:Golang   点击:(1)  评论:(0)  加入收藏
背景在并发处理中,资源争用是一个常见的问题。为了避免资源争用,需要进行优化。以下是一些可以优化并发处理中的资源争用问题的建议: 避免锁竞争:锁竞争是一种常见的资源争用问...【详细内容】
2023-03-10  研道鸠摩智  今日头条  Tags:Go   点击:(0)  评论:(0)  加入收藏
本文我们介绍怎么使用命令行工具 micro new 创建一个 gRPC 服务,并且怎么构建和运行服务。​01 介绍Go 开源项目 Micro​ 为我们提供一套微服务解决方案,它主要包含两个部分...【详细内容】
2023-03-06  Golang语言开发栈  微信公众号  Tags:Go 语言   点击:(6)  评论:(0)  加入收藏
Go 为了自身 goroutine 执行和调度的效率,自身在 runtime 中实现了一套 goroutine 的调度器。 写在前面Go 为了自身 goroutine 执行和调度的效率,自身在 runtime 中实现了一...【详细内容】
2023-03-03  字节跳动技术团队  微信公众号  Tags:Go   点击:(6)  评论:(0)  加入收藏
MySQL中如何优化LIMIT分页?这个问题我们今天一起来聊一聊。以下是一个示例,演示如何优化MySQL 中limit 分页查询的性能:假设我们有一个名为 users 的表,其中存储了 1,000,000 条...【详细内容】
2023-02-27  数据库干货铺  今日头条  Tags:MySQL   点击:(9)  评论:(0)  加入收藏
本文我们介绍了跨平台文件监听库 fsnotify,它主要用于自动监听文件中的内容变更。我们通过 fsnotify 源码和示例代码,介绍了该库支持的功能和使用方式。​1、介绍Go 语言作为...【详细内容】
2023-02-26  frank    Tags:Go 语言   点击:(10)  评论:(0)  加入收藏
本文就介绍两个专门用来开发命令行应用程序的库。在日常开发中,大家对命令行工具(CLI)想必特别熟悉了,如果说你不知道命令工具,那你可能是个假开发。每天都会使用大量的命令行工...【详细内容】
2023-02-21  路多辛  51CTO  Tags:Golang   点击:(11)  评论:(0)  加入收藏
本文我们通过在 Gin 构建的应用中,使用 Zap 记录请求日志,介绍了 Zap 的使用方式,最后还通过 lumberjack 日志切割库进行切割日志。​1、介绍我们在之前的文章中介绍过标准库 l...【详细内容】
2023-02-13  frank  51CTO  Tags:Go   点击:(24)  评论:(0)  加入收藏
在很多情况下,并发的效果比并行好,因为操作系统和硬件的总资源一般很少,但能支持系统同时做很多事情。这种“使用较少的资源做更多的事情”的哲学,也是指导 Go语言设计的哲学。...【详细内容】
2023-02-10  Johnny&王中阳  51CTO  Tags:Go语言   点击:(24)  评论:(0)  加入收藏
站内最新
站内热门
站内头条