Python, is it proper for one thread to spawn another

Question

I am writing an update application in Python 2.x. I have one thread (ticket_server) sitting on a database (CouchDB) url in longpoll mode. Update requests are dumped into this database from an outside application. When a change comes, ticket_server triggers a worker thread (update_manager). The heavy lifting is done in this update_manager thread. There will be telnet connections and ftp uploads performed. So it is of highest importance that this process not be interrupted.

My question is, is it safe to spawn update_manager threads from the ticket_server threads?

The other option might be to put requests into a queue, and have another function wait for a ticket to enter the queue and then pass the request off to an update_manager thread. But, Id rather keeps tings simple (Im assuming the ticket_server spawning update_manager is simple) until I have a reason to expand.

# Here is the heavy lifter
class Update_Manager(threading.Thread):
    def __init__(self)
        threading.Thread.__init__(self, ticket, telnet_ip, ftp_ip)
        self.ticket = ticket   
        self.telnet_ip = telnet_ip
        self.ftp_ip = ftp_ip


    def run(self):
        # This will be a very lengthy process.
        self.do_some_telnet()
        self.do_some_ftp()

    def do_some_telnet(self)
        ...

    def do_some_ftp(self)
        ...

# This guy just passes work orders off to Update_Manager
class Ticket_Server(threading.Thread):
    def __init__(self)
        threading.Thread.__init__(self, database_ip)
        self.database_ip

    def run(self):
        # This function call will block this thread only.
        ticket = self.get_ticket(database_ip)

        # Here is where I question what to do.
        # Should I 1) call the Update thread right from here...
        up_man = Update_Manager(ticket)
        up_man.start

        # Or should I 2) put the ticket into a queue and let some other function
        # not in this thread fire the Update_Manager. 


    def get_ticket()
    # This function will 'wait' for a ticket to get posted. 
    # for those familiar with couchdb:
        url = 'http://' + database_ip:port + '/_changes?feed=longpoll&since=' + update_seq
        response = urllib2.urlopen(url)

This is just a lot of code to ask which approach is the safer/more efficient/more pythonic Im only a few months old with python so these question get my brain stuck in a while loop.

Answer 1

The main thread of a program is a thread; the only way to spawn a thread is from another thread.

Of course, you need to make sure your blocking thread is releasing the GIL while it waits, or other Python threads won't run. All mature Python database bindings will do this, but I've never heard of couchdb.