How to use the gevent.queue.Queue function in gevent

def setUp(self):
        self.log_queue = Queue()
        modbus = modbus_server.ModbusServer('tests/data/basic_modbus_template.xml', self.log_queue, timeout=0.1)
        print modbus._databank
        self.modbus_server = StreamServer(('127.0.0.1', 0), modbus.handle)
        self.modbus_server.start()

def test_join():
    q1 = Queue(1)
    q2 = Queue(2)

    def _run(q, n):
        gevent.sleep(random.random()*2)
        q.put(n)

    Greenlet(_run, q1, 'Item 1').start()
    Greenlet(_run, q2, 'Item 2').start()

    tag, firstItem = joinQueues(q1, q2)

    print 'firstItem:', firstItem
    if tag == 'a':
        print 'waiting for Item2:'
        print q2.get()
    if tag == 'b':
        print 'waiting for Item1:'

def receiver():
    events = gevent.queue.Queue()
    lcm_start_read(str.encode(LCM_TARGETS.UI), events)

    while True:

        if not events.empty():
            event = events.get_nowait()
            print("RECEIVED:", event)
            if event[0] == UI_HEADER.TEAMS_INFO:
                socketio.emit('server-to-ui-teamsinfo', json.dumps(event[1], ensure_ascii=False))
            elif event[0] == UI_HEADER.SCORES:
                socketio.emit('server-to-ui-scores', json.dumps(event[1], ensure_ascii=False))
            elif event[0] == UI_HEADER.CONNECTIONS:
                socketio.emit('server-to-ui-connections', json.dumps(event[1], ensure_ascii=False))
        socketio.sleep(0.1)

self._log = ROOT_LOG.getChild('[%s]' % zk_path)
    self._log.info('TellApart ServerSet intializing on path %s' % zk_path)

    if not isinstance(zk, KazooClient):
      raise TypeError('zk must be an instance of a KazooClient')

    if not zk.connected:
      raise Exception('zk must be in a connected state.')

    self._zk_path = zk_path
    self._zk = zk
    self._nodes = set()
    self._members = {}
    self._on_join = on_join or noop
    self._on_leave = on_leave or noop
    self._notification_queue = Queue(0)
    self._watching = False
    self._cb_blocker = self._CallbackBlocker()
    self._member_filter = member_filter or true
    self._member_factory = member_factory or Member.from_node
    self._running = True
    self._worker = gevent.spawn(self._notification_worker)

    if on_join or on_leave:
      self._monitor()

def __init__(self, parent_actor, factory, uri, node):
        Greenlet.__init__(self)
        if not callable(factory):  # pragma: no cover
            raise TypeError("Provide a callable (such as a class, function or Props) as the factory of the new actor")
        self.factory = factory
        self.parent_actor = parent_actor
        self.uri = uri
        self.node = node
        self.queue = gevent.queue.Queue()
        self.inbox = deque()

def __init__(self, sandbox=True, **kwargs):
        self._send_queue = Queue()
        self._send_queue_cleared = Event()
        self._send_greenlet = None
        self.timeout = INITIAL_TIMEOUT
        self._feedback_queue = Queue()
        if "certfile" not in kwargs:
            raise ValueError(u"Must specify a PEM bundle.")
        if not os.path.exists(kwargs['certfile']):
            raise ValueError('PEM bundle file not found')
        self._sslargs = kwargs
        self._push_connection = None
        self._sandbox = sandbox
        self._error_queue = Queue()
        self._send_greenlet = None
        self._error_greenlet = None
        self._feedback_connection = None
        self._feedback_greenlet = None

def __init__(self, domains, id=0):
        self.domains: List = domains
        self.id: int = id
        self.timeout: int = 2
        self.queue = Queue()
        self.sensitive: Dict = {}
        self.headers: Dict = {'User-Agent': user_agent}
        self.exist_status_code: List[int] = [200, 403]
        self.not_exist_file_type: List[str] = ['/', '.config', '.sql', '.inc', '.bak', '.jsp', '.asp', '.aspx', '.php', '.html']

def joinQueues(a, b):
    # Return an element from either a or b
    q = Queue(1)

    def _handle(chan):
        chan.peek()
        q.put(chan)

    Greenlet(_handle, a).start()
    Greenlet(_handle, b).start()
    c = q.get()
    if c is a: return 'a', a.get()
    if c is b: return 'b', b.get()

"235": 32,
    "234": 20,
    "233": 12,
    "232": 6,
    "231": 4,
    "230": 3,
    "229": 2,
    "228": 2,
    "227": 2,
    "226": 1,
    "225": 0,
    "224": 0,
}

g_battery = 0
tasks = Queue()


def get_level(data, bits):
    """
    Returns sensor level value from data using sensor bit mask in micro volts (uV).
    """
    level = 0
    for i in range(13, -1, -1):
        level <<= 1
        b, o = (bits[i] / 8) + 1, bits[i] % 8
        level |= (ord(data[b]) >> o) & 1
    return level


def is_old_model(serial_number):
    if "GM" in serial_number[-2:]:

def __init__(self, sandbox = True, **kwargs):
		if "certfile" not in kwargs:
			raise ValueError, u"Must specify a PEM bundle."
		self._sslargs = kwargs
		self._push_connection = None
		self._feedback_connection = None
		self._sandbox = sandbox
		self._send_queue = Queue()
		self._error_queue = Queue()
		self._feedback_queue = Queue()
		self._send_greenlet = None
		self._error_greenlet = None
		self._feedback_greenlet = None

		self._send_queue_cleared = Event()