Go-并发任务

最新推荐文章于 2024-04-02 14:06:14 发布
最新推荐文章于 2024-04-02 14:06:14 发布
阅读量272 收藏 1
点赞数 1
分类专栏： go 文章标签： go golang 高并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daichuanrong/article/details/118558641
版权

目录

一、仅执行一次

1、单例模式。

二、仅需任意任务完成

1、场景

2、代码示例

三、所有任务完成

1、场景

2、代码示例

a、CSP方案

b、WaitGroup方案

四、对象池

1、场景

2、代码示例

五、sync.Pool 对象缓存

1、私有对象和共享池

2、sync.Pool 获取对象的顺序

3、Sync.Pool 对象的返回

4、使用 sync.Pool

5、sync.Pool对象的生命周期

a、sync.Pool的基本用法

b、sync.Pool 在多协程中的应用

6、sync.pool总结

六、总结

一、仅执行一次

1、单例模式。

确保在多线程的情况下，某段代码只执行一次，且线程安全。

sync.Once能确保里面的 Do() 方法在多线程的情况下只会被执行一次。

package single_ton

import (
	"fmt"
	"sync"
	"testing"
	"unsafe"
)

type Singleton struct {
	
}

var singleInstance *Singleton
var once sync.Once

//获取一个单例对象
func GetSingletonObj() *Singleton {
	once.Do(func() {
		fmt.Println("Create a singleton Obj")
		singleInstance = new(Singleton)
	})

	return singleInstance
}

//启动多个协程，测试我们单例对象是否只创建了一次
func TestGetSingletonObj(t *testing.T)  {
	var wg sync.WaitGroup
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func() {
			obj := GetSingletonObj()
			fmt.Printf("%x\n", unsafe.Pointer(obj))
			wg.Done()
		}()
	}
	wg.Wait()
}
/*
=== RUN   TestGetSingletonObj
Create a singleton Obj
124cfb8
124cfb8
124cfb8
124cfb8
124cfb8
--- PASS: TestGetSingletonObj (0.00s)
PASS
*/

我们可以看到上面的调试结果，启动多个协程，只打印了一次 "Create a singleton Obj"，而且多个协程返回对象的地址是完全一样的，说明单例模式正常。

二、仅需任意任务完成

1、场景

当我们需要执行许多并发任务，但是只要任意一个任务执行完毕，就可以将结果返回给用户，例如我们想百度和google发起请求，任意一个请求返回结果即可。

2、代码示例

package util_anyone_reply

import (
	"fmt"
	"runtime"
	"testing"
	"time"
)

//从网站上执行搜索功能
func searchFromWebSite(webSite string) string {
	time.Sleep(10 * time.Millisecond)
	return fmt.Sprintf("search from %s", webSite)
}

//收到第一个结果后立刻返回
func FirstResponse() string  {
	var arr = [2]string{"baidu", "google"}
	//这里用 buffer channel 很重要，否则可能导致剩下的协程会被阻塞在那里，
	//当阻塞的协程达到一定量后，最终可能导致服务器资源耗尽而出现重大故障
	ch := make(chan string, len(arr))
	for _, val := range arr {
		go func(v string) {
			//拿到所有结果放入 channel
			ch <- searchFromWebSite(v)
		}(val)
	}

	//这里没有使用 WaitGroup，因为我们的需求是当 channel 收到第一个消息后就立刻返回
	return <-ch
}

func TestFirstResponse(t *testing.T)  {
	t.Log("Before:", runtime.NumGoroutine())
	t.Log(FirstResponse())
	t.Log("After:", runtime.NumGoroutine())
}
/*
=== RUN   TestFirstResponse
    first_response_test.go:35: Before: 2
    first_response_test.go:36: search from baidu
    first_response_test.go:37: After: 3
--- PASS: TestFirstResponse (0.01s)
PASS
*/

三、所有任务完成

1、场景

有时候我们所有任务都完成才进入下一个环节，s我们下单成功后，只有积分和优惠券都赠送了才显示所有优惠赠送成功。

2、代码示例

我们这里采用了两种方案，一种是 CSP 的方案，另一种是 WaitGroup 的方案。

a、CSP方案

package until_all_done

import (
	"fmt"
	"runtime"
	"sync"
	"testing"
	"time"
)

//送豪礼方法
func sendGift(gift string) string {
	time.Sleep(10 * time.Millisecond)
	return fmt.Sprintf("送%s", gift)
}

//使用 CSP 拿到所有的结果才返回
func CspAllResponse() []string {
	var arr = [2]string{"优惠券", "积分"}
	//这里用 buffer channel 很重要，否则可能导致剩下的协程会被阻塞在那里，
	//当阻塞的协程达到一定量后，最终可能导致服务器资源耗尽而出现重大故障
	ch := make(chan string, len(arr))
	for _, val := range arr {
		go func(v string) {
			//拿到所有结果放入 channel
			ch <- sendGift(v)
		}(val)
	}

	var finalRes = make([]string, len(arr), len(arr))
	//等到所有的的协程都执行完毕，把结果一起返回
	for i :=0; i < len(arr); i++ {
		finalRes[i] = <-ch
	}

	return finalRes
}

func TestAllResponse(t *testing.T)  {
	t.Log("Before:", runtime.NumGoroutine())
	t.Log(CspAllResponse())
	t.Log("After:", runtime.NumGoroutine())
}
/*
=== RUN   TestFirstResponse
    until_all_done_test.go:61: Before: 2
    until_all_done_test.go:62: [送优惠券 送积分]
    until_all_done_test.go:64: After: 2
--- PASS: TestFirstResponse (0.02s)
PASS
*/

b、WaitGroup方案

package until_all_done

import (
	"fmt"
	"runtime"
	"sync"
	"testing"
	"time"
)

//送豪礼方法
func sendGift(gift string) string {
	time.Sleep(10 * time.Millisecond)
	return fmt.Sprintf("送%s", gift)
}

//使用 WaitGroup 拿到所有的结果才返回
func WaitGroupAllResponse() []string {
	var arr = [2]string{"优惠券", "积分"}
	var finalRes = make([]string, 0, len(arr))
	var wg sync.WaitGroup

	for _, val := range arr {
		wg.Add(1)
		go func(v string) {
			//拿到所有结果放入 channel
			ret := sendGift(v)
			finalRes = append(finalRes, ret)
			wg.Done()
		}(val)
	}

	wg.Wait()

	return finalRes
}

func TestAllResponse(t *testing.T)  {
	t.Log("Before:", runtime.NumGoroutine())
	t.Log(WaitGroupAllResponse())
	t.Log("After:", runtime.NumGoroutine())
}
/*
=== RUN   TestFirstResponse
    until_all_done_test.go:61: Before: 2
    until_all_done_test.go:63: [送优惠券 送积分]
    until_all_done_test.go:64: After: 2
--- PASS: TestFirstResponse (0.02s)
PASS
*/

四、对象池

1、场景

在我们日常的开发中，经常会有像数据库连接，网络连接等，我们经常需要把它们池话，以免对象被重复创建。在 Go 语言中我们使用 buffered channel 实现对象池。我们可以通过设定 buffer 的大小来设定池的大小，我们可以从这个 buffer 池中拿到一个对象，用完了又还回来。

2、代码示例

package obj_pool

import (
	"errors"
	"fmt"
	"testing"
	"time"
)

//可重用对象
type Reusable struct {

}

//对象池
type ObjPool struct {
	//用于缓存可重用对象
	bufChan chan *Reusable
}

//创建一个包含多个可重用对象的对象池
func NewObjPool(numObjPool int) *ObjPool {
	//声明对象池
	objPool := ObjPool{}

	//初始化 objPool.bufChan 为一个 channel
	objPool.bufChan = make(chan *Reusable, numObjPool)

	//往 objPool 对象池里面放多个可重用对象
	for i:= 0;i < numObjPool ; i++ {
		objPool.bufChan <- &Reusable{}
	}

	return &objPool
}

//从对象池拿到一个对象
func (objPool *ObjPool) GetObj(timeout time.Duration) (*Reusable, error)  {
	select {
	case ret := <- objPool.bufChan:
		return ret, nil
	case <-time.After(timeout):	//超时控制
		return nil, errors.New("time out")
	}
}

//将可重用对象还回对象池
func (objPool *ObjPool) ReleaseObj(ReusableObj *Reusable) error {
	select {
	case objPool.bufChan <- ReusableObj:
		return nil
	default:
		return errors.New("overflow")
	}
}

//从对象池里面拿出对象，用完了又放回去
func TestObjPool(t *testing.T)  {
	pool := NewObjPool(3)
	for i := 0; i < 3; i++ {
		if obj, err := pool.GetObj(time.Second * 1); err != nil {
			t.Error(err)
		} else {
			fmt.Printf("%T\n", obj)
			if err := pool.ReleaseObj(obj); err != nil {
				t.Error(err)
			}
		}
	}

	t.Log("Done")
}

五、sync.Pool 对象缓存

其实 sync.Pool 并不是对象池的类，而是个对象缓存，叫sync.Cache 更贴切，不要被它的名字所误导了。

1、私有对象和共享池

sync.Pool 有两个重要的概念，私有对象和共享池。

  • 私有对象是协程安全的，写入的时候不需要锁。
  • 而共享池是协程不安全的，写入的时候需要锁。

2、sync.Pool 获取对象的顺序

  1. 先尝试从私有对象获取；
  2. 如果私有对象不存在，则尝试从当前 Processor 的共享池获取；
  3. 如果当前 Processor 的共享池也是空的，那么就尝试从其他 Processor 的共享池获取；
  4. 如果所有协程的共享池都是空的，最后就用用户指定的 New 函数产生一个新的对象返回。

3、Sync.Pool 对象的返回

  1. 如果私有对象不存在，则保存为私有对象；
  2. 如果私有对象已经存在，则放入当前 Processor 子池的共享池中。

4、使用 sync.Pool

//使用 New 关键字创建新对象
pool := &sync.Pool{
	New: func() interface{} {
		return 0
	},
}

//从 pool 中获取一个对象，因为返回的是 interface，所有要自己做断言
array := pool.Get().(int)

//往 pool 中放入一个对象
pool.Put(10)

5、sync.Pool对象的生命周期

  • 每次GC都会清除 sync.pool 缓存对象
  • 对象的缓存有效期为下一次 GC之前

由于GC是系统调度的，我们没办法控制，而GC又会自动清除 sync.pool 对象，所以如果我们想长时间控制一个连接的生命周期那就不行。

a、sync.Pool的基本用法

package sync_pool

import (
	"fmt"
	"sync"
	"testing"
)

//调试 sync.Pool 对象
func TestSyncPool(t *testing.T)  {
	pool := &sync.Pool{
		New: func() interface{} {
			fmt.Println("Create a new object")
			return 0
		},
	}

	//第一次从池中获取对象，我们知道它一定是空的，所有肯定会调用 New 方法去创建一个新对象
	v := pool.Get().(int)
	fmt.Println(v)			//0

	//放一个不存在的对象，它会优先放入私有对象
	pool.Put(10)
	//此时私有对象已经存在了，所有会优先拿到私有对象的值
	v1 := pool.Get().(int)
	fmt.Println(v1)			//10

	//模拟系统调用GC, GC会清除 sync.pool中缓存的对象
	//runtime.GC()
}

b、sync.Pool 在多协程中的应用

package sync_pool

import (
	"fmt"
	"sync"
	"testing"
)

//调试 sync.Pool 在多个协程中的应用场景
func TestSyncPoolInMultiGoroutine(t *testing.T) {
	pool := sync.Pool{
		New: func() interface{} {
			return 0
		},
	}

	pool.Put(11)
	pool.Put(12)

	var wg sync.WaitGroup
	for i := 0; i < 5 ; i++ {
		wg.Add(1)
		go func() {
			v, _ := pool.Get().(int)
			fmt.Println(v)
			wg.Done()
		}()
	}
	wg.Wait()
}

/*
=== RUN   TestSyncPoolInMultiGroutine
11
12
0
0
0
--- PASS: TestSyncPoolInMultiGroutine (0.00s)
PASS
*/

6、sync.pool总结

  1. 适合于通过复用，降低复杂对象的创建和 GC 代价；
  2. 协程安全，会有锁的开销；
  3. 生命周期受 GC 影响，不适合于做连接池等需要自己管理生命周期的资源的池化。

六、总结

  • sync.Once能确保里面的 Do() 方法用来生成单例。
  • 通过 buffer channel 拿到第一个结果后立即返回实现仅需任意任务完成即可的功能。
  • 通过 buffer channel 拿到所有结果后才返回实现需要所有任务都完成的功能；
  • 通过 WaitGroup 也可以实现需要所有任务都完成的功能。
  • 通过 buffered channel 实现对象池，用来池化我们的数据库连接等。
  • sync.pool 适合于通过复用，降低复杂对象的创建和 GC 代价，但是不适用于做需要自己管理生命周期的连接池，如数据库连接池等。

注：这篇博文是我学习中的总结，如有转载请注明出处：

https://blog.csdn.net/DaiChuanrong/article/details/118558641

上一篇：Go-Context与任务取消

下一篇：Go-单元测试

袋鼠Roy
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GO语言学习-并发
01-20
GO语言学习-接口interface定义wait阻塞GOMAXPROCS实现Local StorageGoexit通道channel单向通道 定义 并发（concurrency）：逻辑上具备同时处理多个任务的能力。 并行（parallesim）不同于并发，物理上的同一时刻，...
go-piper:用于使用Go语言创建和管理并发任务的库
05-20
- 一种使用管道模式构建Go程序的简单方法。 Go-piper为每个通过非缓冲通道连接的每个管道步骤创建N个goroutine。 输入数据将通过所有步骤的工作人员进行引导，并将结果发送到输出通道。重要的仅在不断消耗您的输出...
Go语言并发详解
qq_41854911的博客
11-09 7379
文章目录一、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 多线程工具使用和分析
daliucheng的博客
06-28 731
Mutex不是一个可重入锁有两种模式，并且两种模式在Mutex运行期间是可以互相切换的。
【Go】十七、进程、线程、协程
最新发布
llg___的博客
04-02 1100
如上，主线程中，开启一个协程，协程每1秒输出hello golang，主线程每一秒输出一次hello 9527，主线程和协程在同时执行，且属于同一个线程（主线程）。协程的引入，给CPU一种：该线程好像是一直在计算，io比较少的错觉，从而会更多的将cpu的执行权限分配给我们的线程。多协程操作同一个数据的问题：按以下1.2.3.4.5.6的步骤，就发现做了一次+1，一次-1，结果为-1。线程是CPU控制的，而协程是程序自身控制的，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级。
GO学习之 协程(goroutine)
qq_19283249的博客
07-31 1790
在 Go 语言中，goroutine 是一种非常轻量的执行单元，有 Go 运行是（runtime）进行调度，不是有固定大小的线程来处理的。与传统线程相比，goroutine的创建和切换开销很小，因此可以创建大量的 goroutine 来并行执行任务，而不会造成太大的系统负担。 * goroutine 更像是一种高效的协程，它在并发编程中提供了轻量且较高的方式来处理并发，而不需要显式地创建和管理线程池。
Go并发编程详解
金戈鐡馬
12-04 1290
随着硬件的发展，并发程序变得越来越重要。Web服务器会一次处理成千上万的请求。平板电脑和手机app在渲染用户画面同时还会后台执行各种计算任务和网络请求。即使是传统的批处理问题--读取数据，计算，写输出--现在也会用并发来隐藏掉I/O的操作延迟以充分利用现代计算机设备的多个核心。计算机的性能每年都在以非线性的速度增长。
Go并发介绍及其使用
二进制杯莫停的博客
02-16 646
当多个 goroutine 同时进行处理的时候，就会遇到比如同时抢占一个资源，某个 goroutine 等待另一个 goroutine 处理完某一个步骤之后才能继续的需求。在 golang 的官方文档上，作者明确指出，golang 并不希望依靠共享内存的方式进行进程的协同操作。而是希望通过管道 channel 的方式进行。当然，golang 也提供了共享内存，锁，等机制进行协同操作的包。sync 包就是为了这个目的而出现的。
【文件夹】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循环...
以最大的并发度运行任务-Golang开发
05-26
cr:open_file_folder:并发运行器概述cr是与可能实现最高并行执行量有关的作业执行器。 给定作业及其依存关系的定义，它会建立一个图t cr:open_file_folder:并发运行程序Overview cr是一个作业执行程序，它关注于实现...
Go语言并发技术详解
12-31
有人把Go比作21世纪的C语言，第一是因为Go语言设计简单，第二，21世纪最重要的就是并行...也正因为如此，可同时运行成千上万个并发任务。goroutine比thread更易用、更高效、更轻便。 goroutine是通过Go的runtime管理的
Go-提供多线程定时任务
08-14
提供多线程定时任务
go语言中常见的并发任务
ZhaoSimonone的博客
06-01 299
本文主要介绍了go中一些常见的并发任务。包括仅执行一次的任务、仅需其中一个任务执行完毕的任务、需要所有任务都完成的任务、使用Bufferer Channel实现对象池以及使用sync.Pool做对象缓存。
go语言的并发原理（goroutine）
ydl1128的博客
08-09 1091
单从线程调度讲，Go语言相比起其他语言的优势在于OS线程是由OS内核来调度的， goroutine 则是由Go运行时（runtime）自己的调度器调度的，完全是在用户态下完成的， 不涉及内核态与用户态之间的频繁切换，包括内存的分配与释放，都是在用户态维护着一块大的内存池， 不直接调用系统的malloc函数（除非内存池需要改变），成本比调度OS线程低很多。只要通道的容量大于零，那么该通道就属于有缓冲的通道，通道的容量表示通道中最大能存放的元素数量。Go 语言中的通道（channel）是一种特殊的类型。...
go语言多线程与并发编程
热门推荐
luoye4321的专栏
09-06 2万+
go语言并发编程 在了解go语言的并发编程之前，我们必须先了解并发和并行的概念。我们知道，当启动一个应用的时候实际上是启动了一个进程，通过该进程实现资源的调度和分配，并且多个进程之间是相互隔离的，所以我们运行其中一个应用不会对其他应用造成影响。 默认情况下一个进程只有一个线程，也就是单线程应用，这种模式下所有的操作都是同步的，处理完A事件以后才能接着处理B事件再接着处理C事件。 那么，单线程...
go并发处理
仅做个人笔记
07-28 526
jobpool： 待处理任务队列 workerpool: 空闲处理者队列 job: 任务类 worker: 处理者类 go: jobpool在前面不断的接收job（jobpool <- job） go: for: worker从jobpool里循环获取job来处理（select {case job := <-jobpool）， go: 当...
【Go】并发编程之 sync：Mutex、RWMutex、WaitGroup、Once
weixin_44211968的博客
02-26 1177
文章目录一、sync 包简介二、互斥锁 Mutex1. 引言 - 并发安全与锁2. 源码：Mutex 结构体3. 互斥锁的三个状态4. 互斥锁上的方法三、读写锁 RWMutex1. 引言 - 多读不互斥2. 源码：RWMutex 结构体3. 读写锁上的方法4. 实例5. 一个要点四、等待组 - sync.WaitGroup1. 引言2. WaitGroup 的作用3. 三个方法4. 源码：WaitGroup 结构体5. 一个注意五、sync.Once参考链接 一、sync 包简介 Go 语言在 sync
Go并发编程（八）go定时器
kevin的博客
05-01 413
文章目录Go并发编程（八）go定时器标准定时器timer循环定时器Tick Go并发编程（八）go定时器 Go的标准包time里提供了两种定时器，一种是标准定时器，另一种是循环定时器。 标准定时器timer timer在到达指定时间时仅仅触发一次，当timer到期时会将当前时间发送到自己的C管道，timer实例必须通过NewTimer或AfterFunc timer := time.NewTimer(time.Second * 3) 延迟执行： 第一种实现 time.sleep(3 * time.Sec
如何学习go语言的并发编程
08-10
1. 学习Goroutine：Goroutine是Go语言并发编程的核心，它是一种轻量级的线程，可以在程序中创建多个Goroutine并发执行，以实现高效的并发编程。需要学习如何创建和管理Goroutine。 2. 学习Channel：Channel是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值