Go典型并发任务

仅运行一次

最容易联想到的单例模式:

type Singleton struct {
}

var singleInstance *Singleton
var once sync.Once

func GetSingletonObj() *Singleton {
	once.Do(func() {
		fmt.Println("Create Obj")
		singleInstance = new(Singleton)
	})
	return singleInstance
}

func TestGetSingletonObj(t *testing.T) {
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			obj := GetSingletonObj()
			fmt.Printf("%x\n", unsafe.Pointer(obj))
			wg.Done()
		}()
	}
	wg.Wait()
	/** 运行结果:
	=== RUN   TestGetSingletonObj
	Create Obj
	1269f78
	1269f78
	1269f78
	1269f78
	1269f78
	1269f78
	1269f78
	1269f78
	1269f78
	1269f78
	--- PASS: TestGetSingletonObj (0.00s)
	*/
}

仅需任意任务完成

任务堆里面,只需任务一个完成就返回。

func runTask(id int) string {
	time.Sleep(10 * time.Millisecond)
	return fmt.Sprintf("the result is from %d", id)
}

func FirstResponse() string {
	numOfRunner := 10
	ch := make(chan string) // 非缓冲channel
	for i := 0; i < numOfRunner; i++ {
		go func(i int) {
			ret := runTask(i)
			ch <- ret
		}(i)
	}
	return <-ch
}

func TestFirstResponse(t *testing.T) {
	t.Log(FirstResponse())
	/** 第一次运行结果:
	=== RUN   TestFirstResponse
	    TestFirstResponse: first_response_test.go:27: the result is from 0
	--- PASS: TestFirstResponse (0.01s)
	*/
	/** 第二次运行结果:
	=== RUN   TestFirstResponse
	    TestFirstResponse: first_response_test.go:27: the result is from 3
	--- PASS: TestFirstResponse (0.01s)
	*/
}

因为协程的调度机制,所以返回结果不一样。

但这样是存在很大的问题,修改TestFirstResponse

func TestFirstResponse(t *testing.T) {
	t.Log("Before:", runtime.NumGoroutine()) // 获取协程数量
	t.Log(FirstResponse())
	time.Sleep(time.Second * 1)
	t.Log("After:", runtime.NumGoroutine()) // 获取协程数量
	/** 运行结果:
	=== RUN   TestFirstResponse
	    TestFirstResponse: first_response_test.go:28: Before: 2
	    TestFirstResponse: first_response_test.go:29: the result is from 6
	    TestFirstResponse: first_response_test.go:30: After: 11
	--- PASS: TestFirstResponse (0.01s)
	*/
}

因为使用的是非缓冲channelFirstResponse方法只取走了一次,往channel放入数据的时候,没有被取走,会造成阻塞。

修改非缓冲channel 为缓冲channel就行,否则会造成资源耗尽。

所有任务完成

之前都是用sync.waitGroup实现,这次利用csp机制实现:

func runTask(id int) string {
	time.Sleep(10 * time.Millisecond)
	return fmt.Sprintf("the result is from %d", id)
}

func AllResponse() string {
	numOfRunner := 10
	ch := make(chan string) // 非缓冲channel
	for i := 0; i < numOfRunner; i++ {
		go func(i int) {
			ret := runTask(i)
			ch <- ret
		}(i)
	}

	finalRet := ""
	for i := 0; i < numOfRunner; i++ {
		finalRet += <-ch + "\n"
	}

	return finalRet
}

func TestFirstResponse(t *testing.T) {
	t.Log(AllResponse())
	/** 运行结果:
	=== RUN   TestFirstResponse
	    TestFirstResponse: all_done_test.go:33: the result is from 9
	        the result is from 0
	        the result is from 2
	        the result is from 7
	        the result is from 4
	        the result is from 6
	        the result is from 1
	        the result is from 5
	        the result is from 8
	        the result is from 3

	--- PASS: TestFirstResponse (0.01s)
	*/
}

对象池

使用 buffered channel 实现对象池

type ReusableObj struct {
}

type ObjPool struct {
	bufChan chan *ReusableObj // 用于缓冲可重用对象
}

func NewObjPool(numOfObj int) *ObjPool {
	objPool := ObjPool{}
	objPool.bufChan = make(chan *ReusableObj, numOfObj)
	// 提前建立好连接
	for i := 0; i < numOfObj; i++ {
		objPool.bufChan <- &ReusableObj{}
	}
	return &objPool
}

// 获取连接
func (p *ObjPool) GetObj(timeout time.Duration) (*ReusableObj, error) {
	select {
	case ret := <-p.bufChan:
		return ret, nil
	case <-time.After(timeout): // 超时控制
		return nil, errors.New("time out")
	}
}

// 放入连接
func (p *ObjPool) ReleaseObj(obj *ReusableObj) error {
	select {
	case p.bufChan <- obj:
		return nil
	default:
		return errors.New("overflow")
	}
}

func TestObjPool(t *testing.T) {
	pool := NewObjPool(10) // 创建对象池

	for i := 0; i < 11; i++ {
		// 从对象池中获取
		if v, err := pool.GetObj(time.Second * 1); err != nil {
			t.Error(err)
		} else {
			fmt.Println(v)
			// 放入对象池
			if err := pool.ReleaseObj(v); err != nil {
				t.Error(err)
			}
		}
	}

	fmt.Println("Done")
}

sync.Pool对象缓存

sync.Pool 对象获取:

  • 尝试从私有对象获取
  • 私有对象不存在,尝试从当前 Processor 的共享池获取
  • 如果当前 Processor 共享池也是空的,那么就尝试去其他 Processor 的共享池获取
  • 如果所有⼦池都是空的,最后就⽤⽤户指定的 New 函数,产⽣⼀个新的对象返回

sync.Pool 对象放回:

  • 如果私有对象不存在则保存为私有对象
  • 如果私有对象存在,放⼊当前 Processor ⼦池的共享池中

sync.Pool 对象生命周期:

  • GC 会清除 sync.Pool 缓存的对象
  • 对象的缓存有效期为下⼀次 GC 之前
func TestSyncPool(t *testing.T) {
	pool := &sync.Pool{
		New: func() interface{} {
			fmt.Println("Create a new object.")
			return 100
		},
	}

	v := pool.Get().(int) // 从池中获取并断言类型
	fmt.Println(v)        // 100

	pool.Put(3)
	v1, _ := pool.Get().(int)
	fmt.Println(v1) // 3

	//在放进去个 2
	pool.Put(2)
	//为了验证生命周期 这里GC一下
	runtime.GC()
	v3, _ := pool.Get().(int)
	fmt.Println(v3) // 100 而不是 2
	/** 运行结果:
	=== RUN   TestSyncPool
	Create a new object.
	100
	3
	Create a new object.
	100
	--- PASS: TestSyncPool (0.00s)
	*/
}
func TestSyncPoolMultiGoroutine(t *testing.T) {
	pool := sync.Pool{
		New: func() interface{} {
			fmt.Println("Create a new object.")
			return 10
		},
	}

	pool.Put(100)
	pool.Put(100)
	pool.Put(100)

	var wg sync.WaitGroup

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			t.Log(pool.Get())
			wg.Done()
		}()
	}
	wg.Wait()
	/** 运行结果:
	=== RUN   TestSyncPoolMultiGoroutine
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 100
	Create a new object.
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	Create a new object.
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 100
	Create a new object.
	Create a new object.
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	Create a new object.
	Create a new object.
	Create a new object.
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 100
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	    TestSyncPoolMultiGoroutine: sync_pool_test.go:59: 10
	--- PASS: TestSyncPoolMultiGoroutine (0.00s)
	*/
}

sync.Pool 总结:

  • 适合于通过复用,降低复杂对象的创建和GC代价
  • 协程安全,会有锁的开销
  • 生命周期受GC影响,不适合于做连接池等,需自己管理生命周期的资源的池化
展开阅读全文

Git 实用技巧

11-24
这几年越来越多的开发团队使用了Git,掌握Git的使用已经越来越重要,已经是一个开发者必备的一项技能;但很多人在刚开始学习Git的时候会遇到很多疑问,比如之前使用过SVN的开发者想不通Git提交代码为什么需要先commit然后再去push,而不是一条命令一次性搞定; 更多的开发者对Git已经入门,不过在遇到一些代码冲突、需要恢复Git代码时候就不知所措,这个时候哪些对 Git掌握得比较好的少数人,就像团队中的神一样,在队友遇到 Git 相关的问题的时候用各种流利的操作来帮助队友于水火。 我去年刚加入新团队,发现一些同事对Git的常规操作没太大问题,但对Git的理解还是比较生疏,比如说分支和分支之间的关联关系、合并代码时候的冲突解决、提交代码前未拉取新代码导致冲突问题的处理等,我在协助处理这些问题的时候也记录各种问题的解决办法,希望整理后通过教程帮助到更多对Git操作进阶的开发者。 本期教程学习方法分为“掌握基础——稳步进阶——熟悉协作”三个层次。从掌握基础的 Git的推送和拉取开始,以案例进行演示,分析每一个步骤的操作方式和原理,从理解Git 工具的操作到学会代码存储结构、演示不同场景下Git遇到问题的不同处理方案。循序渐进让同学们掌握Git工具在团队协作中的整体协作流程。 在教程中会通过大量案例进行分析,案例会模拟在工作中遇到的问题,从最基础的代码提交和拉取、代码冲突解决、代码仓库的数据维护、Git服务端搭建等。为了让同学们容易理解,对Git简单易懂,文章中详细记录了详细的操作步骤,提供大量演示截图和解析。在教程的最后部分,会从提升团队整体效率的角度对Git工具进行讲解,包括规范操作、Gitlab的搭建、钩子事件的应用等。 为了让同学们可以利用碎片化时间来灵活学习,在教程文章中大程度降低了上下文的依赖,让大家可以在工作之余进行学习与实战,并同时掌握里面涉及的Git不常见操作的相关知识,理解Git工具在工作遇到的问题解决思路和方法,相信一定会对大家的前端技能进阶大有帮助。
©️2020 CSDN 皮肤主题: 技术黑板 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值