Python Multi-threading Tutorial

Multi-threading in Python

Multithreading is a concept of executing different pieces of code concurrently. A thread is an entity that can run on the processor individually with its own unique identifier, stack, stack pointer, program counter, state, register set and pointer to the Process Control Block of the process that the thread lives on.

In this tutorial, we will learn with examples on how to do multithreading in Python programming.

threading module is used to achieve mutlithreading in Python.

Create a Thread

To create a thread, you can use threading.Thread() class. The syntax of Thread() class is:

threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

• leave group as None.
• target is the callable object to be invoked by the run() method of Thread.
• name is the Thread name that you can provide and refer to later in the program.
• args is the argument tuple for the target invocation.
• kwargs is a dictionary of keyword arguments for the target invocation.
• daemon is not None, will be set to be daemonic.

Start a Thread

Once you have created a thread using Thread() class, you can start it using Thead.start() method.

t1 = threading.Thread()
t1.start()

Wait until the thread is finished

You can make the Program Counter of the main process to wait until a specific thread is finished. All you have to do is call join() method on the Thread object.

t1.join()

The execution in the main program waits here at this statement until t1 completes its target execution.

Example – Python Mutlithreading with Two Threads

In the following example, we will do multi-threading with two threads. Each thread runs in parallel to the other and is executed whenever processing resources are available to it.

To fully demonstrate this behavior, we will run a function, in each thread, that prints ones and twos.

import threading 
  
def print_one(): 
	for i in range(10):
		print(1)
  
def print_two(): 
	for i in range(10):
		print(2)
  
if __name__ == "__main__": 
	# create threads
	t1 = threading.Thread(target=print_one) 
	t2 = threading.Thread(target=print_two) 
	
	# start thread 1 
	t1.start() 
	# start thread 2 
	t2.start() 
	
	# wait until thread 1 is completely executed 
	t1.join() 
	# wait until thread 2 is completely executed 
	t2.join() 
	# both threads completely executed 
	
	print("Done!")

Output

1
1
1
2
2
2
1
1
2
1
2
2
2
2
2
2
1
1
1
1
Done!

You could observe that after the thread1 has executed the for loop for three iterations, thread2 has got the resources and started executing. It is highly improbable to predict the amount of time a thread could get for execution.

Example – Mutlithreading with Arguments passed to Threads

In our previous example, we started threads with only their targets. Now, we will pass some arguments to them. Also, you can call the same target for different threads.

import threading 
  
def print_x(x, n): 
	for i in range(n):
		print(x)
  
if __name__ == "__main__": 
	# create threads
	t1 = threading.Thread(target=print_x, args=(1, 5,)) 
	t2 = threading.Thread(target=print_x, args=(2, 10,)) 
	
	# start thread 1 
	t1.start() 
	# start thread 2 
	t2.start() 
	
	# wait until thread 1 is completely executed 
	t1.join() 
	# wait until thread 2 is completely executed 
	t2.join() 
	# both threads completely executed 
	
	print("Done!")

Output

1
1
1
2
2
2
2
1
2
1
2
2
2
2
2
Done!

Summary

In this tutorial of Python Examples, we learned how to implement multi-threading in Python programming with the help of well detailed examples.