Multithreading - Subclassing Thread

Python Multithread

So far, we've been using a thread by instantiating the Thread class given by the package (threading.py). To create our own thread in Python, we'll want to make our class to work as a thread. For this, we should subclass our class from the Thread class.

First thing we need to do is to import Thread using the following code:

from threading import Thread

Then, we should subclass our class from the Thread class like this:

class MyThread(Thread):

Just for reference, here is a code snippet from the package for the Thread class:

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:

    def run(self):
        try:
            if self._target:
                self._target(*self._args, **self._kwargs)
        finally:
            # Avoid a refcycle if the thread is running a function with
            # an argument that has a member that points to the thread.
            del self._target, self._args, self._kwargs

As a Thread starts up, it does some basic initialization and then calls its run() method, which calls the target function passed to the constructor. The Thread class represents an activity that runs in a separate thread of control. There are two ways to specify the activity:

1. by passing a callable object to the constructor
2. by overriding the run() method in a subclass

No other methods (except for the constructor) should be overridden in a subclass. In other words, we only override the __init__() and run() methods of a class.

In this section, we will create a subclass of Thread and override run() to do whatever is necessary:

import threading

class MyThread(threading.Thread):

    def run(self):
        pass

if __name__ == '__main__':
    for i in range(3):
	t = MyThread()
	t.start()

Once a thread object is created, its activity must be started by calling the thread's start() method. This invokes the run() method in a separate thread of control.

Once the thread's activity is started, the thread is considered 'alive'. It stops being alive when its run() method terminates - either normally, or by raising an unhandled exception. The is_alive() method tests whether the thread is alive.

import threading
import time

class MyThread(threading.Thread):

    def run(self):
	time.sleep(5)
	return

if __name__ == '__main__':
    for i in range(3):
	t = MyThread()
	t.start()
	print 't.is_alive()=', t.is_alive()
	t.join()
	print 't.is_alive()=', t.is_alive()

Output:

t.is_alive()= True
t.is_alive()= False
t.is_alive()= True
t.is_alive()= False
t.is_alive()= True
t.is_alive()= False

As we can see from the output, each of the three thread is alive just after the start but t.is_alive()=False after terminated.

Before we move forward, for our convenience, let's put a logging feature into a place:

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-9s) %(message)s',)

class MyThread(threading.Thread):

    def run(self):
	logging.debug('running')
	return

if __name__ == '__main__':
    for i in range(3):
	t = MyThread()
	t.start()

Output:

(Thread-1 ) running
(Thread-2 ) running
(Thread-3 ) running

Because the *args and **kwargs values passed to the Thread constructor are saved in private variables, they are not easily accessed from a subclass. To pass arguments to a custom thread type, we need to redefine the constructor to save the values in an instance attribute that can be seen in the subclass:

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-9s) %(message)s',)

class MyThread(threading.Thread):

    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=None, verbose=None):
	super(MyThread,self).__init__(group=group, target=target, 
			              name=name, verbose=verbose)
	self.args = args
	self.kwargs = kwargs
	return

    def run(self):
	logging.debug('running with %s and %s', self.args, self.kwargs)
	return

if __name__ == '__main__':
    for i in range(3):
	t = MyThread(args=(i,), kwargs={'a':1, 'b':2})
	t.start()

Output:

(Thread-1 ) running with (0,) and {'a': 1, 'b': 2}
(Thread-2 ) running with (1,) and {'a': 1, 'b': 2}
(Thread-3 ) running with (2,) and {'a': 1, 'b': 2}

We overrided the __init__() using:

super(MyThread,self).__init__()

For Python 3, we could have used without any args within the super(), like this:

super().__init__()

Python Multithread