class Pool(object):
    def __init__(self, max_size=32, wait_timeout=8, params={}):
        self._maxsize = max_size # 连接池最大连接数
        self._conn_params = params # 连接参数
        self._pool = deque(maxlen=self._maxsize) # 存储连接的双端队列
        self._wait = deque() # 等待获取连接的callback
        self._wait_timeout = wait_timeout # 等待超时时间
        self._count = 0 # 已创建的连接数
        self._started = False # 连接池是否可用
        self._ioloop = IOLoop.current()
        self._event = Event() # 连接池关闭时间，set该时间后，连接池所有的连接关闭
        self._ioloop.add_future(spawn(self.start), lambda future: future) # 在greenlet中启动连接池

    def create_raw_conn(self):
        pass # 通过self._conn_params参数创建新连接，用于重写

    def init_pool(self): # 创建新的连接，并加入到连接池中
        self._count += 1
        conn = self.create_raw_conn()
        self._pool.append(conn)

    @property
    def size(self): # 可用的连接数
        return len(self._pool)

    def get_conn(self):
        while 1:
            if self._pool: # 如果有可用连接，直接返回
                return self._pool.popleft()
            elif self._count < self._maxsize: # 如果没有可用连接，且创建的连接还没有达到最大连接数，则新建连接
                self.init_pool()
            else:
                self.wait_conn() # 如果没有可用连接，且以创建了最大连接数，则等待连接释放

    def wait_conn(self):
        timer = None
        child_gr = greenlet.getcurrent()
        main = child_gr.parent
        try:
            if self._wait_timeout: # 创建计时器，如果等待了超时则抛出异常
                timer = Timeout(self._wait_timeout)
                timer.start()
            self._wait.append(child_gr.switch)
            main.switch() # 切换到父greenlet上，直到child_gr.switch被调用
        except TimeoutException, e:
            raise Exception("timeout wait connections, connections size %s", self.size)
        finally:
            if timer:
                timer.cancel()

    def release(self, conn):
        self._pool.append(conn) # 释放连接，重新加入连接池中
        if self._wait: # 如果有等待的greenlet
            callback = self._wait.popleft()
            self._ioloop.add_callback(callback) # 在下次ioloop过程中切换到等待获取连接的greenlet

    def quit(self): # 关闭连接池
        self._started = False
        self._event.set()

    def _close_all(self):
        for conn in tuple(self._pool):
            conn.close()
        self._pool = None

    def start(self):
        # self.init_pool()
        self._started = True
        self._event.wait()
        self._close_all()

from pymysql.connections import DEBUG, Connection

class ConnectionPool(Pool):
    def __init__(self, max_size=32, keep_alive=7200, mysql_params={}):
        super(ConnectionPool, self).__init__(max_size=max_size, params=mysql_params)
        self._keep_alive = keep_alive # 为避免连接自动断开，配置连接ping周期

    def create_raw_conn(self):
        conn = Connection(**self._conn_params)
        if self._keep_alive:
            self._ioloop.add_timeout(time.time()+self._keep_alive, self._ping, conn)
        return conn

    @green
    def _ping(self, conn):
        if conn in self._pool:
            self._pool.remove(conn)
            conn.ping()
            self.release(conn)
        self._ioloop.add_timeout(time.time()+self._keep_alive, self._ping, conn)