type Cond struct {
   noCopy noCopy

   // 鎖
   L Locker

   // 等待隊列
   notify  notifyList
   checker copyChecker
}

func NeWCond(l Locker) *Cond
func (c *Cond) Broadcast()
func (c *Cond) Signal()
func (c *Cond) Wait()

package main

import (
   "container/list"
   "fmt"
   "math/rand"
   "sync"
   "time"
)

// 連接池
type Pool struct {
   lock    sync.Mutex // 鎖
   clients list.List  // 連接
   cond    *sync.Cond // cond實例
   close   bool       // 是否關閉
}

// Redis Client
type Client struct {
   id int32
}

// 創建Redis Client
func NewClient() *Client {
   return &Client{
      id: rand.Int31n(100000),
   }
}

// 關閉Redis Client
func (this *Client) Close() {
   fmt.Printf("Client:%d 正在關閉", this.id)
}

// 創建連接池
func NewPool(maxConnNum int) *Pool {
   pool := new(Pool)
   pool.cond = sync.NewCond(&pool.lock)

   // 創建連接
   for i := 0; i < maxConnNum; i++ {
      client := NewClient()
      pool.clients.PushBack(client)
   }

   return pool
}

// 從池子中獲取連接
func (this *Pool) Pull() *Client {
   this.lock.Lock()
   defer this.lock.Unlock()

   // 已關閉
   if this.close {
      fmt.Println("Pool is closed")
      return nil
   }

   // 如果連接池沒有連接 需要阻塞
   for this.clients.Len() <= 0 {
      this.cond.Wait()
   }

   // 從鏈表中取出頭節點，刪除并返回
   ele := this.clients.Remove(this.clients.Front())
   return ele.(*Client)
}

// 將連接放回池子
func (this *Pool) Push(client *Client) {
   this.lock.Lock()
   defer this.lock.Unlock()

   if this.close {
      fmt.Println("Pool is closed")
      return
   }

   // 向鏈表尾部插入一個連接
   this.clients.PushBack(client)

   // 喚醒一個正在等待的goruntine
   this.cond.Signal()
}

// 關閉池子
func (this *Pool) Close() {
   this.lock.Lock()
   defer this.lock.Unlock()

   // 關閉連接
   for e := this.clients.Front(); e != nil; e = e.Next() {
      client := e.Value.(*Client)
      client.Close()
   }

   // 重置數據
   this.close = true
   this.clients.Init()
}

func main() {

   var wg sync.WaitGroup

   pool := NewPool(3)
   for i := 1; i <= 10; i++ {
      wg.Add(1)
      go func(index int) {

         defer wg.Done()

         // 獲取一個連接
         client := pool.Pull()

         fmt.Printf("Time:%s | 【goruntine#%d】獲取到client[%d]\n", time.Now().Format("15:04:05"), index, client.id)
         time.Sleep(time.Second * 5)
         fmt.Printf("Time:%s | 【goruntine#%d】使用完畢，將client[%d]放回池子\n", time.Now().Format("15:04:05"), index, client.id)

         // 將連接放回池子
         pool.Push(client)
      }(i)
   }

   wg.Wait()
}

//
//    c.L.Lock()
//    for !condition() {
//        c.Wait()
//    }
//    ... make use of condition ...
//    c.L.Unlock()
//
func (c *Cond) Wait() {
   c.checker.check()
   
   // 添加到等待隊列
   t := runtime_notifyListAdd(&c.notify)
   c.L.Unlock()
   
   // 阻塞
   runtime_notifyListWait(&c.notify, t)
   c.L.Lock()
}

// 如果連接池沒有連接 需要阻塞
for this.clients.Len() <= 0 {
  this.cond.Wait()
}

// 獲取連接
ele := this.clients.Remove(this.clients.Front())
return ele.(*Client)