python Queue一般用于哪些方面，这段代码大概是什么流程意思，谢谢

Question

from ccnet.sync_client import SyncClient
import Queue

class ClientPool(object):
    """ccnet client pool."""

    def __init__(self, conf_dir, pool_size=5):
        """
        :param conf_dir: the ccnet configuration directory
        :param pool_size:
        """
        self.conf_dir = conf_dir
        self.pool_size = pool_size
        self._pool = Queue.Queue(pool_size)

    def _create_client(self):
        client = SyncClient(self.conf_dir)
        client.req_ids = {}
        client.connect_daemon()

        return client

    def get_client(self):
        try:
            client = self._pool.get(False)
        except:
            client = self._create_client()
        return client

    def return_client(self, client):
        try:
            self._pool.put(client, False)
        except Queue.Full:
            pass

class SyncClient(Client):
    '''sync mode client'''
    def __init__(self, config_dir):
        Client.__init__(self, config_dir)
        self._req_id = _REQ_ID_START
        self.mq_req_id = -1

    def disconnect_daemon(self):
        if self.is_connected():
            try:
                self._connfd.close()
            except:
                pass

    def read_response(self):
        packet = read_packet(self._connfd)
        if packet.header.ptype != CCNET_MSG_RESPONSE:
            raise RuntimeError('Invalid Response')

        code, code_msg, content = parse_response(packet.body)

        return Response(code, code_msg, content)

    def send_cmd(self, cmd):
        req_id = self.get_request_id()
        self.send_request(req_id, 'receive-cmd')
        resp = self.read_response()
        if resp.code != '200':
            raise RuntimeError('Failed to send-cmd: %s %s' % (resp.code, resp.code_msg))

        cmd += '\000'
        self.send_update(req_id, '200', '', cmd)

        resp = self.read_response()
        if resp.code != '200':
            raise RuntimeError('Failed to send-cmd: %s %s' % (resp.code, resp.code_msg))

        self.send_update(req_id, SC_PROC_DONE, SS_PROC_DONE, '')

    def prepare_recv_message(self, msg_type):
        request = 'mq-server %s' % msg_type
        req_id = self.get_request_id()
        self.send_request(req_id, request)

        resp = self.read_response()
        if resp.code != '200':
            raise RuntimeError('bad response: %s %s' % (resp.code, resp.code_msg))

    def receive_message(self):
        resp = self.read_response()
        # the message from ccnet daemon has the trailing null byte included
        msg = message_from_string(resp.content[:-1])
        return msg

    def prepare_send_message(self):
        request = 'mq-server'
        mq_req_id = self.get_request_id()
        self.send_request(mq_req_id, request)
        resp = self.read_response()
        if resp.code != '200':
            raise RuntimeError('bad response: %s %s' % (resp.code, resp.code_msg))
        self.mq_req_id = mq_req_id

    def send_message(self, msg_type, content):
        if self.mq_req_id == -1:
            self.prepare_send_message()

        msg = gen_inner_message_string(self.peer_id, msg_type, content)
        self.send_update(self.mq_req_id, "300", '', msg)
        resp = self.read_response()
        if resp.code != '200':
            self.mq_req_id = -1
            raise RuntimeError('bad response: %s %s' % (resp.code, resp.code_msg))

    def register_service_sync(self, service, group):
        '''Mainly used by a program to register a dummy service to ensure only
        single instance of that program is running

        '''
        cmd = 'register-service %s %s' % (service, group)
        self.send_cmd(cmd)

Answer 1

Queue 这个数据结构我比较少用，不过查阅了一下 Python 的说明文档：

The Queue module implements multi-producer, multi-consumer queues. It is especially useful in threaded programming when information must be exchanged safely between multiple threads. The Queue class in this module implements all the required locking semantics. It depends on the availability of thread support in Python; see the threading module.

文档中说明这是一个线程安全的队列，所以可以用在多生产者多消费者的竞态环境中，常见于多线程编程中。

这就是我对 Queue 的理解，现在说会问题中的代码，这段代码从名字上可以比较清晰得看出是一个客户端的池，当你需要获得一个客户端的时候，调用get_client()方法，它会返回一个SyncClient客户端给你，当你用完之后，别忘了调用：return_client(client)换回来，不然，就会产生一大波的客户端，这里这么设计应该是创建大量客户端是会有问题的。

大概就这些了，不知道题主理解了没。

Answer 2

Queue是一个线程安全的队列, 至于给出的代码, @yylucifer解释的比较清楚了,其实就是一个可复用的client池. 这种用法很常见, 可以看redis-py的池子设计, blockconnectionpool那个, 基本都是这个思路.