package main

import (
	"errors"
	"fmt"
	"sync"
	"time"
)

type Pool struct {
	objects chan interface{}   // 使用 channel 存儲對象
	factory func() interface{} // 創(chuàng)建對象的工廠函數(shù)
	mu      sync.Mutex         // 保護對象池
}

var g_index int = 0

func NewPool(size int, factory func() interface{}) *Pool {
	if size <= 0 {
		panic("對象池大小必須大于 0")
	}
	pool := make(chan interface{}, size)
	for i := 0; i < size; i++ {
		pool <- factory() // 預(yù)先創(chuàng)建對象并放入對象池
	}
	return &Pool{
		objects: pool,
		factory: factory,
	}
}

func (p *Pool) Get() interface{} {
	select {
	case obj := <-p.objects:
		return obj // 從對象池中獲取對象
	default:
		// 對象池為空，創(chuàng)建新對象
		fmt.Println("create new object")
		p.mu.Lock()
		defer p.mu.Unlock()
		return p.factory()
	}
}

func (p *Pool) Put(obj interface{}) error {
	select {
	case p.objects <- obj: // 對象放回對象池
		return nil
	default:
		// 對象池已滿，丟棄對象
		obj2 := obj.(*MyObject)
		fmt.Println("pool is full, discard object", obj2.index)
		obj = nil
		return errors.New("pool is full")
	}
}

func (p *Pool) Len() int {
	return len(p.objects)
}

type MyObject struct {
	Data  string
	index int
}

func main() {
	// 創(chuàng)建對象工廠
	objectFactory := func() interface{} {
		g_index += 1
		return &MyObject{Data: "Initial Data", index: g_index}
	}

	// 創(chuàng)建對象池，大小為 10
	pool := NewPool(10, objectFactory)

	var wg sync.WaitGroup
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func(idx int) {
			fmt.Println("pool len:", pool.Len())
			obj := pool.Get().(*MyObject)
			defer func() {
				wg.Done()
				pool.Put(obj)
			}()
			fmt.Println("from :", obj.Data, obj.index, idx)
			time.Sleep(time.Millisecond * 2) // 模擬一些工作
		}(i)
	}
	wg.Wait()
}