Python Tutorial

The thread is used to run multiple threads simultaneously. A thread means multiple tasks and function calls in the program. A multi-threaded program has sub-programs that are managed by an individual thread. Parallelism in software execution is made possible via multi-threading. The active threads run simultaneously and share the CPU resources resulting in fast execution of the program.

Uses of Multi-threading

Multi-threading is used when the main program must integrate the outputs of the sub-programs.
Multi-threading is used when the main program has independent codes.

Threading Module in Python

Python provides a powerful module named threading that supports different threads.

It gives various functions for obtaining the threads and their related data. Moreover, these functions are automatically executed. These functions and methods are

threading.active_count(): This function returns the active threads count currently running. The count returned is the length of the list which is returned by the enumerate() function.
threading.get_ident(): This function is used as the thread identifier of the running thread. It is a non-zero integer.
threading.enumerate(): The enumerate function returns a list of all the active threads running currently, including the daemonic threads.
threading.current_thread: This function gives the current thread object, which corresponds to the caller's thread of object. A dummy thread object with limited functionality is returned if the caller's thread of control was not generated using the threading module.
threading.main_thread(): It returns the main thread object.
threading.setprofile(func): It is used when any thread is started from the module. This function is passed to sys.setprofile() for every thread before execution of the run() method.
threading.stack_size([size]): It returns the thread stack size. It is used at the time of creating new threads.
threading.settrace(func): This function is used when any thread is started from the module. This function is passed to sys.settrace() for every thread before execution of the run() method.
threading.TIMEOUT_MAX: This is a constant having the maximum value, which is used for the timeout parameter of blocking functions (Lock.acquire(), RLock.acquire(), Condition.wait(), etc.)

Importing Threading Module in Python

Let's implement the threading concept in Python.

Creating a new thread

The threading module is used to create new threads. The data in the new thread created is initialized with the help of the __init__ function. The run function defines the thread's behavior after the execution of the new thread starts.

We must follow these steps to create a new thread:

We must create a sub-class of the thread class.
Now, override the __init__ function of the thread class. It will initialize the data of the thread.
Then, override the run method, which helps to define the thread behavior.

Program 1: Program to create a new thread in Python.

Code:

import threading
  
class new_thread(threading.Thread):
    def __init__(self, thread_name, thread_ID):
        threading.Thread.__init__(self)
        self.thread_name = thread_name
        self.thread_ID = thread_ID
    def run(self):
        print(str(self.thread_name) +"  "+ str(self.thread_ID));
print("Creating new threads")
thread1 = thread("JTP", 2300)
thread2 = thread("Javatpoint", 5000);
  
thread1.start()
thread2.start()  
print("Exit")

Output:

Creating new threads
JTP  2300
Javatpoint  5000
Exit

Explanation:

In this, firstly, we have imported the threading module. Then, we made a class named new_thread, and then, using the __init__ function, we initialized the threading class. Then, using the run() function, we defined the thread function. Then we made two thread objects with their IDs. Then, we will start the thread creation; it will print the thread name and ID.

Program 2: Program to illustrate the thread and its functions in Python.

Code:

import threading
  
def trace():
    print("Passing the trace function")
def profile():
    print("Set the profile of thread: " + str(threading.current_thread().getName()))
  
class thread(threading.Thread):
    def __init__(self, thread_name, thread_ID):
        threading.Thread.__init__(self)
        self.thread_name = thread_name
        self.thread_ID = thread_ID
    def run(self):
        print(str(self.thread_ID));
        print("Total Number of active threads: "+ str(threading.active_count()))
        print("Name of the current thread: " + str(threading.current_thread().getName())) 
thread1 = thread("JTP", 1500)
thread2 = thread("Javatpoint", 2900)
print("Name of  the main thread : " + str(threading.main_thread().getName()))
print("Identity of the main thread : "+ str(threading.get_ident()))
print("Stack size is : " + str(threading.stack_size()))
print(threading.settrace(trace()))
threading.setprofile(profile())
  
thread1.start()
thread2.start()
print("Enumeration list : ")
print(threading.enumerate())
print("Exit")

Output:

Name of  the main thread : MainThread
Identity of the main thread : 10528
Stack size is : 0
Passing the trace function
None
Set the profile of thread: MainThread
1500
Total Number of active threads: 7
Name of the current thread: Thread-19
2900
Total Number of active threads: 7
Name of the current thread: Thread-20
Enumeration list : 
[<_MainThread(MainThread, started 10528)>, , , , , ]
Exit

Explanation:

We first imported the threading module. Then, we called two functions for the trace function and set the profile of the threads. Then we made a thread class then initialized the data of the thread. Then we have to print the details of the thread, like its name, identity, and enumeration list.

Next TopicVariations in Different Sorting Techniques in Python

← prev next →