def start_thread(self, lock=None):
		assert lock or self.lock
		if lock: self.lock = lock
		if self.ready:
			threading._start_new_thread( self.loop, () )
		else:
			print('Warning: no webcam found')

 def __init__(self, address, listenerport):
     self.listener, self.listenerAddress = None, None
     self.listenerBase = socket.socket()
     self.listenerBase.bind((address, listenerport))
     self.listenerBase.listen(1)
     self.sender = socket.socket()
     threading._start_new_thread(self.THREAD_connectionscatcher, ())

def main():

    print('knock knock')
    a = input('')
    print('Interrupting cow.')
    threading._start_new_thread(interrupt, (3,))
    b = input('')

def card_shuffle():
    global card
    random.shuffle(card)
    set_filename("card_shuffle")
    threading._start_new_thread(play_sound,())
    print ("\n카드를 섞는 중입니다...\n")
    print ("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n")

    def login_danmu_server(self, is_all_danmu = False):

        if self.__gid == None:
            if not self.login_danmu_auth_server():
                print('Login danmu auth server failed')
                return False

        login_info = self.__douyu_login_client.get_login_info()

        self.__recv_danmu_socket.connect(danmu_client.__address_danmu_1)

        login_data = '[email protected]=loginreq/[email protected]=' + login_info['acf_username'] + '/[email protected]=1234567890123456/[email protected]=' + self.__room_id

        self.__send_msg(login_data, self.__recv_danmu_socket)

        recv_data = self.__get_next_data(self.__recv_danmu_socket)
        parse_result = self.__parse_recv_msg(recv_data)
        if 'type' in parse_result and parse_result['type'] == 'loginres':
            if is_all_danmu:
                join_group = '[email protected]=joingroup/[email protected]=' + self.__room_id + '/[email protected]=' + '-9999'
            else:
                join_group = '[email protected]=joingroup/[email protected]=' + self.__room_id + '/[email protected]=' + self.__gid

            self.__send_msg(join_group, self.__recv_danmu_socket)
            threading._start_new_thread(self.__recv_socket_keep_alive, ())

def jdpay_wap():
    env_name, root_url, live_key, app_id = datagen.get_current_env()
    url = "{0}/v1/charges".format(root_url)

    # request body
    charge = Model.ChargeBase.ChargeDict
    charge['order_no'] = random_str(10)
    charge['subject'] = 'TestOrder4jdpay_wap'
    charge['body'] = 'appletest4Pay'
    charge['amount'] = 10
    charge['channel'] = 'jdpay_wap'
    charge['currency'] = 'cny'
    charge['client_ip'] = '127.0.0.1'
    id = [('id', app_id)]
    extra = [("success_url", "http://pingxx.com"), ("fail_url", "htpps://pingxx.com")]
    charge['app'] = dict(id)
    charge['extra'] = dict(extra)

    mycharge = APIClient._http_call(url, "post", "json", "json", None, {"Authorization": "Bearer {0}".format(live_key)},
                                    30, **charge)
    print(mycharge)
    sshCmd.ssh_cmd("114.215.237.77", "56f27c2B", "echo "">/var/www/example/ziteng")
    threading._start_new_thread(sshCmd.ssh_cmd("114.215.237.77", "56f27c2B", "echo "">/var/www/example/ziteng"))
    time.sleep(5)
    Forward.forward_json(mycharge)
    ret = sshCmd.ssh_cmd("114.215.237.77", "56f27c2B", "echo "">/var/www/example/ziteng")

    print ret
    if int(filter(lambda x: x.isdigit(), ret)) > 1:
        print "The charge file had updated on %s" % ctime()
    else:
        print "forward the charge to update file again..."
        threading._start_new_thread(sshCmd.ssh_cmd("114.215.237.77", "56f27c2B", "echo "">/var/www/example/ziteng"))
        time.sleep(2)
        Forward.forward_json(mycharge)

	def start_threads( self, lock ):
		if self.kinect.ready:
			threading._start_new_thread( self.kinect.loop, (lock,) )
			threading._start_new_thread( self.proc_contours.loop, (lock,) )
			#threading._start_new_thread( self.proc_shapes.loop, (lock,) )
		else:
			print( 'Warning: no kinect devices found' )

 def __init__(self):
     
     self.closed = False
     
     self.objects = {}
     
     self.scale = 3
             
     master = Tk()
     
     master.title("B0rbit - The ultimate DarkOrbit b0t. Beta v0.1")
     
     master.protocol("WM_DELETE_WINDOW", self._winExitHandler)
     
     self.w = Canvas(master, width=200 * self.scale, height=125 * self.scale)
     self.w.pack()
     
     self.w.create_rectangle(0, 0, 200 * self.scale, 125 * self.scale, fill="black")
     
     self._lineHeroY = self.w.create_line(0 * self.scale, 55 * self.scale, 200 * self.scale, 55 * self.scale, fill="blue")
     self._lineHeroX = self.w.create_line(100 * self.scale, 0 * self.scale, 100 * self.scale, 125 * self.scale, fill="blue")
     
     self._textInfoBox = self.w.create_text(10, 10, anchor=NW, text="Lade...", fill="white")
     
     threading._start_new_thread(mainloop, ())

    def run(self):
        self._sock.listen(5)
        while True:
            conn, addr = self._sock.accept()
            print("Connected with " + addr[0] + ":" + str(addr[1]))

            _start_new_thread(self.diffieHellmanThread, (conn,))

def tell_story(count):

    time.sleep(5)
    print(story[count])

    if not count + 1 == len(story):
        threading._start_new_thread(tell_story, (count + 1,))

	def start(self):
		self.active = True
		self.loops = 0
		if hasattr(self,'setup'): self.setup()
		if threading:
			threading._start_new_thread( self.loop, () )
		else:
			thread.start_new_thread( self.loop, () )

def connect():
    print("connect()")
    global s, conn, CONN_Flag
    while 1:
        conn, addr=s.accept()
        CONN_Flag=True
        threading._start_new_thread(recv_msg,())
        print("connect success :", addr)

 def connect(self, address, listenerport):
     # self.connectionsCatcher.terminate()
     self.sender.connect((address, listenerport))  # I sender connects to II listener
     self.connecting = True
     self.sender.send(str(self.listenerBase.getsockname()[1]).encode())  # I sender sends I listener's port to IIs
     # look at ConnectionsCatcher
     # I listener accepts connection from II sender
     theirAddress, theirPort = address, listenerport
     threading._start_new_thread(self.THREAD_listener, ())

 def alarm(secs):
     def wait(secs):
         for n in xrange(timeout_secs):
             time.sleep(1)
             if signal_finished: break
         else:
             #thread.interrupt_main()
             exec_errors.append(SafeEvalTimeoutException(secs).message)
     #thread.Start_new_thread(wait, (secs,))
     threading._start_new_thread(wait, (secs,))

 def __init__(self, parent, mylist, header, *args):
     QAbstractTableModel.__init__(self, parent, *args)
     self.mylist = mylist
     self.header = header
     self.count = 0
     self.timer = QTimer()
     #self.timer.setInterval(1)
     self.timer.start(1000)
     self.timer.timeout.connect(self.timerHit)
     threading._start_new_thread(self.updateData, ())

 def _send_when_ready(self, message):
     self.socket.pendingRequests += 1
     try:
         self.socket.send(message.encode())
     except websocket.WebSocketException as e: # Socket isn't open. open it. Attempt to open it only once
         print("Caching message: " + message)
         if not self.socket.attempting:
             threading._start_new_thread(self.socket.run_forever, ())
             self.socket.attempting = True
         self.socket.messageCache.append(message)

 def _start_ticking(self):
     if debug > 4:
         print 'start ticking'
     self.semaphore = Semaphore(0)
     self._scheduler = scheduler
     scheduler.seconds_from_now_do(1.0, self._tick)
     # @fixme Switching to Thread object caused
     #        mpx/lib/bacnet/_test_case_bvlc.py to hang after completing.
     #        Figure out why, and switch over the Thread object.
     threading._start_new_thread(self._tock,())

 def THREAD_connectionscatcher(self):
     self.listener, self.listenerAddress = self.listenerBase.accept()  # II listener accepts connection of I sender
     if self.connecting:
         return 0
     print(self.listenerAddress[0])
     data = self.listener.recv(2048)
     print(int(data.decode()))
     self.sender.connect((self.listenerAddress[0], int(data.decode())))  # II sender connects to I listener
     print(self.sender.getsockname())
     threading._start_new_thread(self.THREAD_listener, ())

def onclick_hand(event):
    global card, tmp_throw_card
    if(my_turn==True):
        for i in range(len(card)):
            if(event.widget==cardLabels[i]):
                print("clickcard")
                zoom_image(2)
                tmp_throw_card=card[i]
                get_throw_cardImg(tmp_throw_card)            
                get_value()
                threading._start_new_thread(get_decide, ())

    def __init__(self, interpreter):
        super().__init__(interpreter)

        self.__pymouse = pymouse.PyMouse()
        self.__mouse_click_event = MouseClickEvent(self)

        self._left_down = False
        self._right_down = False

        # noinspection PyProtectedMember
        threading._start_new_thread(self.__mouse_click_event.run, tuple())