import os
import sys
import signal

import config
import core

def start():
    global core_main
    core_main = core.Core()
    core_main.start()

def stop():
    print "Stoping..."
    core_main.stop()

if __name__ == '__main__':
    signal.signal(signal.SIGINT, lambda *a: stop())
    start()

    def join(self):
        while not self.is_alive():
            time.sleep(1.0)

class RPCThread(threading.Thread):

    flag_stop = True

    def __init__(self):
        super(RPCThread, self).__init__()
        addr = (config.RPC_SERVER_ADDRESS, config.RPC_SERVER_PORT)
        self.rpc = SimpleXMLRPCServer(addr)
        self.log = logging.getLogger(self.__class__.__name__)

    def stop(self):
        self.log.info("Stoping")
        self.flag_stop = True

    def run(self):
        self.log.info("Starting")
        self.flag_stop = False
        ...
        self.serve_forever()

    def join(self):
        while not self.isAlive():
            time.sleep(1.0)

    def serve_forever(self):
        """Handle requests while stop"""
        while not self.flag_stop:
            self.handle_request()
...

flag_stop = False
while not flag_stop:
    time.sleep(1.0)

   def join(self, timeout=None):
        if not self.__initialized:
            raise RuntimeError("Thread.__init__() not called")
        if not self.__started.is_set():
            raise RuntimeError("cannot join thread before it is started")
        if self is current_thread():
            raise RuntimeError("cannot join current thread")

        if __debug__:
            if not self.__stopped:
                self._note("%s.join(): waiting until thread stops", self)
        self.__block.acquire()
        try:
            if timeout is None:
                while not self.__stopped:
                    self.__block.wait()
                if __debug__:
                    self._note("%s.join(): thread stopped", self)
            else:
                deadline = _time() + timeout
                while not self.__stopped:
                    delay = deadline - _time()
                    if delay <= 0:
                        if __debug__:
                            self._note("%s.join(): timed out", self)
                        break
                    self.__block.wait(delay)
                else:
                    if __debug__:
                        self._note("%s.join(): thread stopped", self)
        finally:
            self.__block.release()

def join(self, timeout=1.0):
    while self.isAlive():
        super(threading.Thread, self).join(timeout)

#!/usr/bin/env python
# vim: sw=4 ts=4 expandtab ai

import time
import threading
import signal

class Trtest(threading.Thread):

    def __init__(self):
        self.flagstop = False
        super(Trtest, self).__init__()

    def run(self):
        print "start"
        self.flagstop = False
        while not self.flagstop:
            print "run loop    flag =", self.flagstop
            time.sleep(1.0)

    def join(self, timeout=1.0):
        while self.isAlive():
            super(Trtest, self).join(timeout)

    def stop(self):
        print "stop"
        self.flagstop = True

t = Trtest()
signal.signal(signal.SIGINT, lambda *a: t.stop())
t.start()
t.join()
print "Done!"

super(threading.Thread, self).join(timeout)

super(Trtest, self).join(timeout)

 alex@kubu-book:~/development/PYTHON_projects$ python ./threadtest.py 
start
run loop
Traceback (most recent call last):
  File "./threadtest.py", line 32, in <module>
    t.join()
  File "./threadtest.py", line 23, in join
    super(threading.Thread, self).join(timeout)
AttributeError: 'super' object has no attribute 'join'
Exception AttributeError: "'super' object has no attribute 'join'" in <module 'threading' from '/usr/lib/python2.6/threading.pyc'> ignored

 alex@kubu-book:~/development/PYTHON_projects$ python ./threadtest.py
start
run loop    flag = False
run loop    flag = False
run loop    flag = False
run loop    flag = False
^Cstop
Done!
 alex@kubu-book:~/development/PYTHON_projects$

for i in `seq 100`; do python ./threadtest.py & sleep $i; kill -2 %1; sleep 2.0;  done