1. package main
    3. import (
    4.     "errors"
    5.     "fmt"
    6.     "sync"
    7.     "time"
    8. )
    10. type ReusableObj struct {
    11. }
    13. type ObjPool struct {
    14.     bufChan chan *ReusableObj
    15. }
    17. func (this *ObjPool) GetObj(timeout time.Duration) (*ReusableObj, error) {
    18.     select {
    19.     case ret := <-this.bufChan:
    20.         return ret, nil
    21.     case <-time.After(timeout):
    22.         return nil, errors.New("timeout")
    23.     }
    24. }
    26. func (this *ObjPool) ReleaseObj(obj *ReusableObj) error {
    27.     select {
    28.     case this.bufChan <- obj:
    29.         return nil
    30.     default:
    31.         return errors.New("overflow")
    32.     }
    33. }
    35. func NewObjPool(NumOfObj int) *ObjPool {
    36.     objPool := ObjPool{bufChan: make(chan *ReusableObj, NumOfObj)}
    37.     for i := 0; i < NumOfObj; i++ {
    38.         objPool.bufChan <- &ReusableObj{}
    39.     }
    40.     return &objPool
    41. }
    43. func main() {
    44.     pool := NewObjPool(10)
    45.     wg := sync.WaitGroup{}
    46.     for i := 0; i < 200; i++ {
    47.         go func() {
    48.             wg.Add(1)
    49.             defer wg.Done()
    50.             v, err := pool.GetObj(time.Second * 3)
    51.             if err != nil {
    52.                 fmt.Println(err)
    53.                 return
    54.             }
    55.             time.Sleep(time.Millisecond * 100)
    56.             fmt.Println("do something")
    57.             err = pool.ReleaseObj(v)
    58.             if err != nil {
    59.                 fmt.Println(err)
    60.                 return
    61.             }
    62.         }()
    63.     }
    64.     wg.Wait()
    65.     fmt.Println("Done!")
    66. }