go并发编程 - Pool对象重复利用和Once数据懒加载

sync.Pool

sync.Pool 是 Go 语言标准库中提供的一个对象池（Object Pool）实现，用于复用对象以减少内存分配和垃圾回收的开销。对象池可以提高性能，特别是在高并发环境下。

使用 sync.Pool 时，可以将需要复用的对象放入池中，以便后续需要时可以直接从池中获取，而不需要重新创建。当对象被使用完毕后，可以将其放回池中以便复用。

sync.Pool 的重点是重用对象，而不是限制对象的数量。池中的对象数量会根据需求动态增长和缩减，池中对象的生命周期由 GC（垃圾回收器）控制。

当从池中获取对象时，首先会尝试从池中取出复用的对象。如果池中没有可用的对象，那么将会调用 New 方法创建一个新的对象。获取对象时，应该进行类型断言（type assertion）来获取正确的对象类型。

需要注意的是，sync.Pool 并不保证对象在池中的生存时间或复用次数。在高并发环境下，对象可能会被多个 goroutine 同时获取和使用，需要确保对象的状态是安全可复用的。

值得一提的是，对 sync.Pool 的使用并不适用于所有情况。它主要适合于短时间内创建和销毁的对象，而不适用于长时间存储的对象，因为长时间存储对象可能会导致内存过度使用。

总结起来，sync.Pool 是 Go 语言标准库提供的一个对象池实现，用于复用对象以减少内存分配和垃圾回收的开销。它适用于短时间内创建和销毁的对象，并提供了一种高效的对象重用机制。

package _case

import (
	"fmt"
	"log"
	"math/rand"
	"sync"
)

func PoolCase() {
	target := "192.168.239.149"
	pool, err := GetPool(target)
	if err != nil {
		log.Fatal(err)
	}

	//创建连接池后，先放入10个连接
	for i := 0; i <= 10; i++ {
		coon := &Conn{
			ID:     int64(i),
			Target: target,
			Status: ON,
		}
		pool.Put(coon)
	}

	wg := sync.WaitGroup{}
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for j := 0; j < 5; j++ {
				conn := pool.Get()
				fmt.Println(conn.ID)
				pool.Put(conn)
			}
		}()
	}
}

连接池

const (
	ON  = 1
	OFF = 0
)

// Conn 链接池
type Conn struct {
	ID     int64
	Target string
	Status int
}

func (c *Conn) GetStatus() int {
	return c.Status
}

func NewConn(target string) *Conn {
	return &Conn{
		ID:     rand.Int63(),
		Target: target,
		Status: ON,
	}
}

ConnPool 创建Pool对象

// ConnPool 创建Pool对象
type ConnPool struct {
	sync.Pool
}

GetPool 在链接池取出

// GetPool 在链接池取出
func GetPool(target string) (*ConnPool, error) {
	return &ConnPool{
		Pool: sync.Pool{
			New: func() any { //初始化连接
				return NewConn(target)
			},
		},
	}, nil
}

Get 获取连接池,返回连接

// Get 获取连接池,返回连接
func (c *ConnPool) Get() *Conn {
	conn := c.Pool.Get().(*Conn)
	if conn.GetStatus() == OFF { //如果连接池被关闭
		conn = c.Pool.New().(*Conn)
	}
	return conn
}

Put 释放连接

// Put 释放连接
func (c *ConnPool) Put(conn *Conn) {
	if conn.GetStatus() == OFF {
		return
	}

	c.Pool.Put(conn)
}

注意事项

1. 用户缓存一些创建成本较高， 使用比较频繁的对象
2. Pool的长度默认为机器CPU线程数
3. 存储在Pool中的对象随时都可能在不被通知的情况下回收
4. 没有什么创建成本的对象不建议使用对象池

sync.Once

sync.Once 是 Go 语言标准库中提供的一种同步原语，用于保证某个操作只执行一次。通常用于在多个 goroutine 之间共享一个全局或者一次性初始化的资源。

sync.Once 类型具有一个 Do 方法，该方法接收一个函数作为参数并执行该函数。第一次调用 Do 方法时，会执行传入的函数；而后续的调用则会被忽略，不再执行该函数。

sync.Once 内部通过一个互斥锁和一个标志位实现。在第一次调用 Do 方法时，goroutine 会获取到互斥锁并检查标志位。如果标志位为 false，表示该操作尚未执行，则执行传入的函数并将标志位设置为 true；如果标志位为 true，则直接跳过函数的执行。无论是函数执行还是跳过，最后都会释放互斥锁，并且后续的调用都不会再获取互斥锁。

sync.Once 的典型用途是进行一次性资源初始化。例如，可以使用 sync.Once 来确保只有一个 goroutine 对某个全局变量进行初始化，而后续的读取操作可以直接使用该已初始化的值，而无需重复初始化。

需要注意的是，被传入 Do 方法的函数可能会被调用多次，但是 sync.Once 会确保只有第一次调用会执行实际的函数体。

总结而言，sync.Once 是 Go 语言标准库提供的一种同步原语，用于保证某个操作只执行一次。它适用于在多个 goroutine 之间共享全局或一次性初始化的资源，并提供了一种高效的初始化机制
使用sync.Once函数只被调用一次

package _case

import (
	"fmt"
	"sync"
)

type onceMap struct {
	sync.Once
	data map[string]int
}

func (m *onceMap) LoadData() {
	m.Do(func() {
		list := []string{"A", "B", "C", "D"}
		for _, item := range list {
			_, ok := m.data[item]
			if !ok {
				m.data[item] = 0
			}
			m.data[item] += 1
		}
	}) //只调用一次该函数
}

调用10次函数只得到一次结果

func OnceCase() {
	o := &onceMap{
		data: make(map[string]int),
	}
	wg := sync.WaitGroup{}

	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			o.LoadData()
		}()
	}
	wg.Wait()
	fmt.Println(o.data)	//map[A:1 B:1 C:1 D:1]
}