\n<\/span><\/p>\n
So, let’s start the Multithreading in Python Tutorial.<\/p>\n
![\"Python](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/03\/Multithreading-in-Python-01.jpg\")
<\/a>Python Multithreading – Functions, Threads, and Locks in Multithreading<\/p><\/div>\n
What is Python Multithreading?<\/h3>\n
Let’s understand first what a thread is in Python.<\/p>\n
- \n
- A thread is the smallest unit of execution in a process.<\/li>\n
- It is said to be a lightweight process as it has multiple threads that can run in a process.<\/li>\n
- Threads share the same memory, code, and variables.<\/li>\n<\/ul>\n
Functions in Python Multithreading<\/h3>\n
We have the following functions in the Python Multithreading module:<\/p>\n
![\"Python](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/03\/Functions-in-Python-Multithreading-01.jpg\")
<\/a>Python Multithreading Tutorial – Functions of Multithreading in Python<\/p><\/div>\n
1. active_count() in Python Multithreading<\/h4>\n
This returns the number of alive(currently) Thread objects. This is equal to the length of the list that enumerate() returns.<\/p>\n
>>> threading.active_count()<\/pre>\n
Output<\/strong><\/p>\n
2<\/div>\n2. current_thread() in Python Multithreading<\/h4>\n
Based on the caller\u2019s thread of control, this returns the current Thread object.<\/p>\n
If this thread of control isn\u2019t through \u2018threading\u2019, it returns a dummy thread object with limited functionality.<\/p>\n
>>> threading.current_thread()<\/pre>\n
Output<\/strong><\/p>\n
<_MainThread(MainThread, started 14352)><\/div>\n3. get_ident() in Python Multithreading<\/h4>\n
get_ident() returns the current thread\u2019s identifier, which is a non-zero integer. We can use this to index a dictionary of thread-specific data.<\/p>\n
Apart from that, it has no special meaning. When one thread exits, and another creates, Python recycles such an identifier.<\/p>\n
>>> threading.get_ident()<\/pre>\n
Output<\/strong><\/p>\n
14352<\/div>\n4. enumerate() in Python Multithreading<\/h4>\n
This returns a list of all alive(currently) Thread objects. This includes the main thread, daemonic threads, and dummy thread objects created by current_thread().<\/p>\n
This obviously doesn\u2019t include terminated threads as well as those that haven\u2019t begun yet.<\/p>\n
>>> threading.enumerate()<\/pre>\n
Output<\/strong><\/p>\n
\n[<_MainThread(MainThread, started 14352)>, <Thread(SockThread, started daemon 9864)><\/p>\n<\/div>\n
5. main_thread() in Python Multithreading<\/h4>\n
This method returns the main Thread object. Normally, it is that thread that started the interpreter.<\/p>\n
>>> threading.main_thread()<\/pre>\n
Output<\/strong><\/p>\n
\n<_MainThread(MainThread, started 14352)><\/p>\n<\/div>\n
6. settrace(func) in Python Multithreading<\/h4>\n
settrace() traces a function for all threads we started using \u2018threading\u2019. The argument func passes to sys.settrace() for each thread before it calls its run() method.<\/p>\n
>>> def sayhi():\r\n print(\"Hi\")\r\n>>> threading.settrace(sayhi)\r\n>>><\/pre>\n
7. setprofile(func) in Python Multithreading<\/h4>\n
This method sets a profile function for all threads we started from \u2018threading\u2019. It passes func<\/i> to sys.setprofile() for each thread before it calls its run() method.<\/p>\n
>>> threading.setprofile(sayhi)\r\n>>><\/pre>\n
8. stack_size([size]) in Python Multithreading<\/h4>\n
stack_size() returns the stack size of a thread when creating new threads. \u00a0size <\/i>is the stack size we want to use for subsequently created threads.<\/p>\n
This must be equal to 0 or a positive integer of value at least 32,768 (32KiB). When not specified, it uses 0.<\/p>\n
And if it doesn\u2019t support changing thread stack size, it raises a RuntimeError.<\/p>\n
When we pass an invalid stack size, it raises a ValueError and does not modify it.<\/p>\n
The minimum stack size it currently supports to guarantee enough stack space for the interpreter itself is 32KiB.<\/p>\n
Some platforms may need a minimum stack size of greater than 32KiB. Others may need to allocate in multiples of the system memory page size.<\/p>\n
>>> threading.stack_size()<\/pre>\n
Apart from functions, \u2018threading\u2019 also defines a constant.<\/p>\n
9. TIMEOUT_MAX in Python Multithreading<\/h4>\n
This holds the maximum allowed value for this constant, the timeout parameter for blocking functions like Lock.acquire(), Condition.wait(), RLock.acquire(), and others.<\/p>\n
If we denote a timeout greater than this, it raises an OverflowError.<\/p>\n
>>> threading.TIMEOUT_MAX<\/pre>\n
Output<\/strong><\/p>\n
\n4294967.0<\/p>\n<\/div>\n
In Java, locks and condition variables are the basic behavior of every object. Whereas in Python, they are individual objects.<\/p>\n
Here, the class Thread supports some of the functionality of class Thread in Java.<\/p>\n
However, currently, we have no thread groups, priorities, and we cannot destroy, stop, suspend, resume, or interrupt threads.<\/p>\n
When we implement the static methods from Java\u2019s Thread, they map to module-level functions. This way, \u2018threading\u2019 is much like Java\u2019s threading model in design.<\/p>\n
Next in the Python Multithreading tutorial is Thread – Local Data and Thread Objects.<\/p>\n
Python Thread-Local Data<\/h3>\n
That data for which the values are thread-specific is thread-local. To manage such data, we can create an instance of local\/a subclass and then store attributes on it.<\/p>\n
>>> mydata=threading.local()\r\n>>> mydata.x=7\r\n>>><\/pre>\n
These instance values differ for each thread. We have the following class denoting thread-local data:<\/p>\n
class threading.local<\/p>\n
Next in the Python Multithreading Tutorial is Thread Objects.<\/p>\n
Python Thread Objects<\/h3>\n
The Thread class that we mentioned earlier in this blog denotes an activity running in a separate thread of control.<\/p>\n
We can represent this activity either by passing a callable object to the constructor, ot by overriding the method run() in a subclass.<\/p>\n
You must make sure not to override other methods in a subclass, except for the constructor. In short, only override a class\u2019 __init__() and run() methods.<\/p>\n
Once the interpreter creates a thread object, we must start its activity by calling its start() method. This will invoke its run() method in a separate thread of control.<\/p>\n
Once this happens, we consider the thread to be \u2018alive\u2019. When run() terminates normally or raising an exception we did not handle, it is no longer alive.<\/p>\n
To test whether a thread is alive, we may use the method is_alive().<\/p>\n
A thread may call another\u2019s join() method. This will block the calling thread until the other terminates.<\/p>\n
Threads have names, and we can pass these names to the constructor, and even read or modify them.<\/p>\n
We can flag a thread as a \u2018daemon thread\u2019. This means that the whole program exits when only the daemon threads remain.<\/p>\n
This initial value comes from the creating thread. We can set this flag via the property \u2018daemon\u2019, or via the constructor argument \u2018daemon\u2019.<\/p>\n
Daemons abruptly stop at shutdown, and they may not properly release all the resources held. These resources may include open files, database transactions, and others.<\/p>\n
To stop our threads gracefully, we must make them non-daemonic. It is also preferable to use a suitable signaling process, like an Event.<\/p>\n
The \u2018main thread\u2019 object pertains to the initial thread of control in our program; it isn\u2019t a daemon.<\/p>\n
Finally, it is possible that the interpreter creates \u2018dummy thread objects\u2019. These are \u2018alien threads\u2019 (threads of control started outside \u2018threading\u2019, for ex, directly from C code).<\/p>\n
Such objects have limited functionality and are always live and daemonic. We cannot join() them. We can also never delete them since it is impossible to detect when they terminate.<\/p>\n
This is the class:<\/p>\n
class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)<\/p>\n
Take note:<\/p>\n