multithreading - creating threads

Python Multithread

Using threads allows a program to run multiple operations concurrently in the same process space. Through out this tutorials, we'll be using threading module. Note that there is another module called thread which has been renamed to _thread in Python 3. Actually, the threading module constructs higher-level threading interfaces on top of the lower level _thread module. We rarely touch the low level _thread module.

The Thread class is defined in http://hg.python.org/cpython/file/3.4/Lib/threading.py.

The __init__() of the Thread class looks like this:

def __init__(self, group=None, target=None, name=None,
             args=(), kwargs=None, *, daemon=None):

In this section, we'll start with the simplest way to use a Thread. So, as shown in the code below, we instantiate it with a target function f() and call start() to let it begin working. The target is the callable object to be invoked by the run() method. Defaults to None, meaning nothing is called.

import threading

def f():
    print 'thread function'
    return

if __name__ == '__main__':
    for i in range(3):
        t = threading.Thread(target=f)
        t.start()

The start() starts the thread's activity. It must be called at most once per thread object. It arranges for the object's run() method to be invoked in a separate thread of control.

This method will raise a RuntimeError if called more than once on the same thread object.

The code will output "thread function" three times:

thread function
thread function
thread function

The run() method is called by start() method (check threading.py):

class Thread:
    ...

    def start(self):
        """Start the thread's activity.

        It must be called at most once per thread object. It arranges for the
        object's run() method to be invoked in a separate thread of control.

        This method will raise a RuntimeError if called more than once on the
        same thread object.

        """
        if not self._initialized:
            raise RuntimeError("thread.__init__() not called")

        if self._started.is_set():
            raise RuntimeError("threads can only be started once")
        with _active_limbo_lock:
            _limbo[self] = self
        try:
            _start_new_thread(self._bootstrap, ())
        except Exception:
            with _active_limbo_lock:
                del _limbo[self]
            raise
        self._started.wait()

    def _bootstrap(self):
        try:
            self._bootstrap_inner()
        except:
            if self._daemonic and _sys is None:
                return
            raise

    def _bootstrap_inner(self):
        try:
         ...

            try:
                self.run()
            except SystemExit:
                pass
            except:

To make a thread more useful, we want to pass args to give more information about the work. The code below passes an integer for thread id, and then the thread prints it. The args is the argument tuple for the target invocation. Defaults to ().

import threading

def f(id):
    print 'thread function %s' %(id)
    return

if __name__ == '__main__':
    for i in range(3):
        t = threading.Thread(target=f, args=(i,))
        t.start()

New output:

thread function 0
thread function 1
thread function 2

Now the integer argument is included in the message printed by each thread.