Go语言并发模式

利用goroutine和channel进行go的并发模式,实现一个资源池实例(《Go语言实战》书中实例稍作修改)

资源池可以存储一定数量的资源,用户程序从资源池获取资源进行使用,使用完成将资源释放回资源池

程序

pool.go

package pool

import (
"errors"
"io"
"log"
"sync"
"time"
) type Pool struct {
m sync.Mutex
resource chan io.Closer
//创建资源的方法,由用户程序自己生成传入
factory func() (io.Closer, error)
closed bool
//资源池获取资源超时时间
timeout <-chan time.Time
} //资源池关闭标志
var ErrPoolClosed = errors.New("资源池已经关闭")
//超时标志
var ErrTimeout = errors.New("获取资源超时") //新建资源池
func New(fn func() (io.Closer, error), size int) (*Pool, error) {
if size <= 0 {
return nil, errors.New("新建资源池大小太小")
}
//新建资源池
p := Pool{
factory: fn,
resource: make(chan io.Closer, size),
}
//向资源池循环添加资源,直到池满
for count := 1; count <= cap(p.resource); count++ {
r, err := fn()
if err != nil {
log.Println("添加资源失败,创建资源方法返回nil")
break
}
log.Println("资源加入资源池")
p.resource <- r
}
log.Println("资源池已满,返回资源池")
return &p, nil
} //获取资源
func (p *Pool) Acquire(d time.Duration) (io.Closer, error) {
//设置d时间后超时
p.timeout = time.After(d)
select {
case r, ok := <-p.resource:
log.Println("获取", "共享资源")
if !ok {
return nil, ErrPoolClosed
}
return r, nil
case <-p.timeout:
return nil, ErrTimeout
}
} //放回资源池
func (p *Pool) Release(r io.Closer) {
//上互斥锁,和Close方法对应,不同时操作
p.m.Lock()
defer p.m.Unlock() if p.closed {
r.Close()
return
}
//资源放回队列
select {
case p.resource <- r:
log.Println("资源放回队列")
default:
log.Println("资源队列已满,释放资源")
r.Close()
}
} //关闭资源池
func (p *Pool) Close() {
//互斥锁,保证同步,和Release方法相关,用同一把锁
p.m.Lock()
defer p.m.Unlock() if p.closed {
return
}
p.closed = true
//清空通道资源之前,将通道关闭,否则引起死锁
close(p.resource)
for r := range p.resource {
r.Close()
}
}

main.go

package main

import (
"gopro/patterns/pool"
"io"
"log"
"math/rand"
"sync"
"sync/atomic"
"time"
) const (
maxGoroutines = 25
pooledResources = 2
) //实现接口类型 资源类型
type dbConnection struct {
ID int32
} //实现接口方法
func (conn *dbConnection) Close() error {
log.Printf("资源关闭,ID:%d\n", conn.ID)
return nil
} //给每个连接资源给id
var idCounter int32
//创建新资源
func createConnection() (io.Closer, error) {
id := atomic.AddInt32(&idCounter, 1)
log.Printf("创建新资源,id:%d\n", id)
return &dbConnection{ID: id}, nil
} //测试资源池
func performQueries(query int, p *pool.Pool) {
conn, err := p.Acquire(10 * time.Second)
if err != nil {
log.Println("获取资源超时")
log.Println(err)
return
}
//方法结束后将资源放进资源池
defer p.Release(conn)
//模拟使用资源
time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)
log.Printf("查询goroutine id:%d,资源ID:%d\n", query, conn.(*dbConnection).ID)
} func main() {
var wg sync.WaitGroup
wg.Add(maxGoroutines) p, err := pool.New(createConnection, pooledResources)
if err != nil {
log.Println(err)
} //每个goroutine一个查询,每个查询从资源池中获取资源
for query := 0; query < maxGoroutines; query++ {
go func(q int) {
performQueries(q, p)
wg.Done()
}(query)
} //主线程等待
wg.Wait()
log.Println("程序结束")
//释放资源
p.Close()
}

执行结果

循环使用两个资源

// :: 创建新资源,id:
// :: 资源加入资源池
// :: 创建新资源,id:
// :: 资源加入资源池
// :: 资源池已满,返回资源池
// :: 获取 共享资源
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 程序结束
// :: 资源关闭,ID:
// :: 资源关闭,ID:

超时结果

修改超时时间为很短

conn, err := p.Acquire( * time.Second)

结果:

// :: 创建新资源,id:
// :: 资源加入资源池
// :: 创建新资源,id:
// :: 资源加入资源池
// :: 资源池已满,返回资源池
// :: 获取 共享资源
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 获取 共享资源
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 获取资源超时
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 查询goroutine id:,资源ID:
// :: 资源放回队列
// :: 程序结束
// :: 资源关闭,ID:
// :: 资源关闭,ID:

Go语言-并发模式-资源池实例(pool)的更多相关文章

  1. Go语言-并发模式-goroutine池实例(work)

    介绍 使用无缓冲的通道来创建一个 goroutine 池,这些 goroutine 执行并控制一组工作,让其并发执行.在这种情况下,使用无缓冲的通道要比随意指定一个缓冲区大小的有缓冲的通道好,因为这个 ...

  2. 《Go语言实战》摘录:7.2 并发模式 - pool

    7.2 并发模式 - pool

  3. WCF实例上下文模式与并发模式对性能的影响

    实例上下文模式 InstanceContextMode 控制在响应客户端调用时,如何分配服务实例.InstanceContextMode 可以设置为以下值: •Single – 为所有客户端调用分配一 ...

  4. go语言】Goroutines 并发模式

    并发模式 让我们先来回顾一下boring函数的例子. func boring(msg string, c chan string) {    for i := 0; ; i++ {         c ...

  5. 《Go语言实战》摘录:7.3 并发模式 - work

    7.3 并发模式 - work

  6. 《Go语言实战》摘录:7.1 并发模式 - runner

    7.1 并发模式 - runner

  7. 《C#并发编程经典实例》笔记

    1.前言 2.开宗明义 3.开发原则和要点 (1)并发编程概述 (2)异步编程基础 (3)并行开发的基础 (4)测试技巧 (5)集合 (6)函数式OOP (7)同步 1.前言 最近趁着项目的一段平稳期 ...

  8. Go并发模式:管道与取消

    关键字:Go语言,管道,取消机制,并发,sync.WaitGroup,包引用,通道,defer,select GO并发模式:管道与取消 简介 Go的并发能力可以使构建一个流数据管道变得非常容易,并且可 ...

  9. 09. Go 语言并发

    Go 语言并发 并发指在同一时间内可以执行多个任务.并发编程含义比较广泛,包含多线程编程.多进程编程及分布式程序等.本章讲解的并发含义属于多线程编程. Go 语言通过编译器运行时(runtime),从 ...

随机推荐

  1. 吴裕雄--天生自然java开发常用类库学习笔记:SortedSet接口

    import java.util.SortedSet ; import java.util.TreeSet ; public class TreeSetDemo05{ public static vo ...

  2. 关于cvPyrSegmentation(src, dst, storage, &comp, level, threshold1, threshold2)函数报错的问题解答

    先挂上我写的代码: #define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <highgui.h> #incl ...

  3. HihoCoder第九周 状态压缩 二 与POJ2411总结

    在此我向各位博友求助,特别想知道除了HihoCoder上面的结果要对1e9+7取余之外,这两道题还有什么其他的问题,都是骨牌覆盖问题,都是状态压缩+dp,为什么我能过poj2411的程序过不了Hiho ...

  4. cf 543 D. Road Improvement

    (懒得想了,,又是DP) #include<bits/stdc++.h> #define N 200005 #define LL long long #define inf 0x3f3f3 ...

  5. redis以服务模式开机启动

    第一步 修改redis为后台启动 vim /usr/redis/redis.conf #路径根据实际情况决定 # By default Redis does not run as a daemon. ...

  6. python---生成式

    1.[(x,y) for x in [1,2,3] for y in [4,2,3] if x == y] (x,y):输出表达式,产生最终列表的元素 for x in [1,2,3] for y i ...

  7. POJ 1944:Fiber Communications

    Fiber Communications Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 4236   Accepted: 1 ...

  8. mysql行级锁和表级锁的区别

    表级锁:开销小,加锁快:不会出现死锁:锁定粒度大,发生锁冲突的概率最高,并发度最低:行级锁:开销大,加锁慢:会出现死锁:锁定粒度最小,发生锁冲突的概率最低,并发度也最高:

  9. 高次同余方程 $BSGS$

    第一篇\(Blog\)... 还是决定把\(luogu\)上的那篇搬过来了. BSGS,又名北上广深 它可以用来求\(a^x \equiv b (mod \ n)\)这个同余方程的一个解,其中\(a, ...

  10. 使用navicat连接mysql8.0.12版本 出现client does not support。。。解决办法

    navicat版本的问题 出现连接失败的原因:mysql8 之前的版本中加密规则是mysql_native_password,而在mysql8之后,加密规则是caching_sha2_password ...