Threading in Python

Dr Ian Cornelius

Hello

Hello (1)

Learning Outcomes

Understand the concept of threading in Python
Demonstrate their knowledge on the use of threading in Python

Threading

Threading (1)

A thread refers to a basic unit of CPU utilisation
- a separate process that has its own instructions and data
- it may also represent a process that is part of a parallel program
  - although it may also represent an independent program
They share their code, data and other operating system resources with other threads belonging to the same process
A traditional process will have a single thread of control
- if a process has multiple threads of control, then it has the ability to perform more than one task at a time

We briefly touched upon multiprocessing in the previous lecture on programming paradigms, in this lecture we shall now look at this in more depth and how we would go about using this approach in Python. However, before we can begin, we need to cover some basic information about what a thread is, and what is meant by this term.

The term thread refers to a basic unit of CPU utilisation, this is a separate process that will consist of its own instruction and data. It could also represent a process which is a part of a parallel program, although it could be represented as an independent program or script. Simply, a thread is a separate flow of execution, which means that the script can perform two actions at once.

However, in Python threading does not actually occur at the same time, they appear to do so, but ultimately they do not. We may often think of threading as having two or more different processors running for your application, with each one doing an independent task at the same time. However, that is not strictly the case. Whilst the threads may be running on different processors, they are only running one at a time.

Threading (2)

Benefits of Multithreading

Responsiveness
- Interactive applications can continue to run, even if part of its blocked; increasing the responsiveness to the user
- Multithreaded web browsers enable you to continue browsing the internet on one tab, whilst another tab has become unresponsive
Resource Sharing
- Threads share memory and resources of the process they belong to
- Benefits of sharing code and data
- allows an application to have several threads of activity in the same address space
Economy
- Allocation of memory and other resources for process creation is costly
- Threads share resources of a process they belong to
  - therefore, providing a cost-effective resource
Multiprocessor Architecture
- Threads may run in parallel on different processors, dependent upon the multiprocessor architecture
- Single threaded processes may only run on one CPU, no matter how many CPUs may be available
- Multithreaded processes on a multi-CPU machine can increase concurrency

There are some key benefits to be achieved when it comes to multithreading your application or script.

The first benefit (and in no particular order) is the responsiveness of an application or script that you are working upon. The script is able to continue running and starting new tasks whilst a prior task is still computing in the background. This can aid the user by increasing the responsiveness of the application and enabling them to continue working.

The second benefit is resource sharing, and as a default, threads will share memory and resources of an operating system to the process that they belong to. This can aid developers to share code and data. This will allow an application to have several threads of activity situated in the same address space.

The third benefit is the economy. When it comes to creating a process, the allocation of memory and resources is costly in terms of time and space. Therefore, since our threads can share the memory in which the process belongs to, it is more economical to create and context switch threads. It is much more time-consuming for creating and managing processes than it is with threads.

Finally, our last benefit is multiprocessor architecture. Threads have the ability to run in parallel and a variety of different processors and their architecture. A single threaded process may only run on a single CPU, no matter the number of CPUs that may be available inside the machine. However, a multithreaded process on a multi-CPU machine can increase concurrency.

Threading (3)

Difference Between Process and Thread i

In multithreading, a process and thread are two closely related terms
- they have the same goal to make a computer run tasks simultaneously
A process can contain one or more threads, whilst a thread cannot contain a process

Threading (4)

Difference Between Process and Thread ii

Process

An execution of a script/program to perform a task
The operating system will assist in the creation, scheduling and termination of the processes
Spawned processes from the main process are known as child processes
The properties of a process are:
- creating each process requires separate system calls for each process
- an isolated execution entity and does not share data or information
- requires more system calls to manage

Threading (5)

Difference Between Process and Thread iii

Thread

An execution of a segment that is part of the process
- a process can consist of multiple threads
- all threads will be executed at the same time
Considered to be lightweight and managed by a scheduler
The properties of a thread are:
- a single system call can create multiple threads
- threads can share data and information between themselves
- management of threads consumes fewer (or none) system calls

Threading (6)

Advantages and Disadvantages of Threading i

Advantages

Speed
- Multithreading can improve the speed of computation
- Each core (or processor) can handle separate threads concurrently.
Responsiveness
- Applications can remain responsive as one thread waits for the input
- Another thread can run the GUI at the same time
Variable Accessibility
- All threads of a particular process can access global variables
- If a change is made to a global variable, then it is visible in the other threads too
Resource Utilisation
- Running several threads in each application utilises the resources of a CPU better
- Idle time of a CPU decreases
Data Sharing
- No requirement for extra space to be created for each thread
- Threads within an application can share the same data

It is only right that we discuss the advantages and disadvantages of multithreading your script/application, so you can make an informed decision on whether it is right for you or not.

It may be apparent already that some key advantages of threading a script come in regard to the speed and responsiveness of the script. Each core, or processor, of a CPU can handle multiple threads concurrently which can improve the speed of computation. This can be especially handy when it comes to brute-forcing a password hash for a password of length five or more.

You may want to consider splitting the logic of string generation into multiple threads. For example, one could handle generating strings beginning with upper-case alpha characters, another with lower-case alpha and maybe another beginning with numerical characters. Threading can also enable data sharing between threads, as long as they are located within the same application process. For example, if the password hash has been cracked in one thread, then a flag can be set which would terminate the other processes.

Threading (7)

Advantages and Disadvantages of Threading ii

Disadvantages

Suitability
- Multithreading is not suitable for single processor systems
- Difficult to achieve performance gains compared to a multiprocessor system
Security
- As threads can share the same data, there is an issue with security
- Any unknown thread may make changes to the data
Complex
- Multithreading can increase the complexity of the application and debugging
Possible Deadlock
- There is a possibility of leading to a deadlock state
- Deadlock is a situation where a set of processes are blocked
  - this is due to each process is holding a resource and is awaiting another acquired by a different process
Synchronisation
- Avoiding mutual exclusion is achieved by synchronisation
- Leads to more memory and CPU utilisation

However, with every advantage, there is a disadvantage. Most notably, with threading, this can be related to suitability. Whilst it is becoming less common to see machines with a single processor, it is becoming more difficult to gain performance gains compared to multiprocessor systems. There is also the complexity of creating a multi-threading application. They require a little more effort from the developer, of which some of you may have come across when attempting to thread the brute-forcing algorithm from your coursework in the first year.

Finally, there is the possibility of a deadlock occurring. This is where a situation arises where a set of processes are blocked. This could be due to each process holding a resource and awaiting to acquire it from a different process.

Multithreading Models

Multithreading Models (1)

There are two types of threads:
1. User Level
2. Kernel Level

Multithreading Models (2)

User Level Threads

These are threads managed by the user
The thread management kernel is not aware of the existence of these threads
The library used for managing threads can be used to:
- create and delete threads
- pass messages and data between threads
- schedule thread execution
- save and restore thread contexts
Advantages:
- Switching threads does not require kernel mode privileges
- User level threads can run on any operating system
- These types of threads are fast to create and manage
Disadvantages:
- For a typical operating system, most system calls are blocked
- A multithreaded application cannot take advantage of multiprocessing

User level threads are threads that are created and managed by the user. When these types of threads are created, the kernel thread manager is not aware of their existence. The library for managing these types of threads can be used to create, and delete threads, pass messages and data between the threads, schedule their execution and save and restore contexts.

Some advantages to these threads are that they do not require kernel mode privileges to switch them, and they can run on any operating system. Some disadvantages with user-level threads is that system calls can be blocked, and multithreaded applications are unable to take advantage of multiprocessing.

Multithreading Models (3)

Kernel Level Threads

These are threads managed by the operating system
- there is no thread management code in the application
Any application can be programmed to be multithreaded
All the threads in the application are supported within a single process
The kernel maintains context information for the process as a whole
- along with the individual threads within the process
Scheduling by the kernel is done on a thread basis
- performs the thread creation, scheduling and management in the kernel space
Advantages:
- Simultaneous scheduling of multiple threads from the same process on multiple processes
- If a single thread is blocked, the kernel is able to schedule another thread for the same process
Disadvantages:
- Generally slower to create and manage compared to user-level threads
- Transfer of control from one thread to another within the same process requires a mode switch

the operating system manages kernel level threads, and in this instance, there is no reason (or requirement) to manage them inside the application or script. In this instance, any application can be developed in a manner that makes it multithreaded, and these threads are all supported inside a single process.

Using kernel level threads can ensure that simultaneous scheduling of multiple threads can be achieved for the same process on multiple processes. Therefore, if a single thread is blocked, the kernel is then able to schedule another thread for the same process to run.

However, with this type of thread, they are generally slower to create and manage when compared to a user-level thread. This can also impede the transfer of control from one thread to another that exists within the same process. If you wish to transfer control, then a method of switching them is required.

Multithreading Models (4)

There are three methods of modeling a multithreaded application:
1. Many-to-One
2. Many-to-Many
3. One-to-One

Multithreading Models (5)

Many-to-One

Maps many user-level threads to one kernel thread
Management of the thread is done by the thread library in the user-space
Only a single thread can access the kernel at a time
- therefore, multiple threads are unable to run in parallel on multiprocessors

graph BT;
    id1((K)) -----> id2((2));
    id1((K)) -----> id3((3));
    id1((K)) -----> id4((4));
    id1((K)) -----> id5((5));

Multithreading Models (6)

Many-to-Many

Joins many user-level threads to a smaller or equal number of kernel threads
The number of kernel threads may be specific to a particular application or machine
Developers are able to create as many user threads as necessary
- the corresponding kernel threads can run in parallel on multiprocessor machines

graph BT;
    id1((K)) -----> id4((1));
    id2((K)) -----> id4((1));
    id3((K)) -----> id4((1));
       
    id1((K)) -----> id5((2));
    id2((K)) -----> id5((2));
    id3((K)) -----> id5((2));
    
    id1((K)) -----> id6((3));
    id2((K)) -----> id6((3));
    id3((K)) -----> id6((3));
    
    id1((K)) -----> id7((4));
    id2((K)) -----> id7((4));
    id3((K)) -----> id7((4));

Multithreading Models (7)

One-to-One

Maps each user-level thread to a kernel thread
Provides more concurrency than the many-to-one model
- allows multiple threads to run in parallel on multiprocessors
Creating a user thread requires creating the corresponding kernel thread
The overhead required for creating a kernel thread can be a burden on the performance of the application

graph BT;
    id1((K)) -----> id2((1));
    id3((K)) -----> id4((1));
    id5((K)) -----> id6((1));
    id7((K)) -----> id8((1));

Multithreading in Python

Multithreading in Python (1)

Python has two libraries available for multithreading applications:
1. _thread: each thread is a function
2. threading: each thread is an object
For the purpose of this module, we shall be focusing upon the threading module
- _thread is considered to be deprecated

Multithreading in Python (2)

Creating a Threaded Application

Implement threads in an object-oriented methodology, as such providing high-level support
To implement a thread, the Thread class is used
- e.g. from theading import Thread
We can then create an instance of the Thread class
Specify the function to run in the target argument
Execute the thread using the start function

from threading import Thread
def hello():
    print("Hello 5062CEM!")
threadExample1 = Thread(target=hello)

threadExample1.start() -> Hello 5062CEM!

As I have mentioned previously, the threading module uses the object-oriented methodology to assist in the development of a multithreaded application. To begin implementing, you will need to import the Thread class, and that is with an upper-case T at the beginning. To run a function as a thread in Python, we need to:

create an instance of the Thread class
specify the name of the function in the target argument
call the start() function at the end

You can see from the code example on the screen; I have created a function called hello. The function is relatively simple, and will print the value Hello 5062CEM when the function has been executed. To go about creating our thread, we create a new variable, in this instance I have called my thread threadExample1. We then call our Thread class that we have imported, and use the target argument to point towards the specific function we wish to run, in this instance it is hello.

Note here that I did not supply the empty brackets at the end of the function name, the convention we would normally follow when we are calling a function. This is because they are not required, and when it comes to supplying arguments, we shall be using an alternative method, more on this soon.

Once we have created our variable, with the Thread object, we can now execute our thread by calling the start function on the variable. This will then begin the thread, and print Hello 5062CEM to the terminal window.

Multithreading in Python (3)

Running a Function with an Argument

Create an instance of the Thread class
Specify the function to run in the target argument
Specify the arguments to pass th`rough in theargs` argument
- provide the arguments as list
Execute the thread using the start function

from threading import Thread
def hello(name):
    print(f"Hello {name}, and welcome to 5062CEM!")
threadExample1  = Thread(target=hello, args=(['Ian Cornelius']))

threadExample1.start() -> Hello Ian Cornelius, and welcome to 5062CEM!

The previous example was a simple function that did not consist of any parameters. Therefore, what is the process for passing through arguments? Well it is similar to the previous method, but we use an additional argument in our Thread object to supply the arguments we want to pass through. It is important to note here that when we are passing through our values, they need to be supplied as a list.

You can see in the code example on the screen, we have adjusted our Thread object instantiation with the args argument, and supplied the argument Ian Cornelius inside a list. When it comes to executing the thread, we can see that the string, Hello Ian Cornelius, and welcome to 5062CEM! is printed to the screen.

Multithreading in Python (4)

Running a Function with Multiple Arguments

Create an instance of the Thread class
Specify the function to run in the target argument
Specify the arguments to pass through in the args argument
- provide the arguments as list
Execute the thread using the start function

from threading import Thread
def hello(name, module):
    print(f"Hello {name}, and welcome to {module}!")
threadExample1 = Thread(target=hello, args=['Ian Cornelius', '5062CEM'])

threadExample1.start() -> Hello Ian Cornelius, and welcome to 5062CEM!

Multithreading in Python (5)

Creating a Custom Thread Class

Extend an instance of the Thread class
Override the run function
Provide variable names with the self keyword
Return the string to the self.data variable

from threading import Thread
class MyThread(Thread):
    def __init__(self, name, module):
        Thread.__init__(self)
        self.name = name
        self.module = module
        self.data = None
    def run(self):
        self.data = f"Hello {self.name}, and welcome to {self.module}!"
customThreadExample1 = MyThread("Ian Cornelius ", "5062CEM")
customThreadExample2 = MyThread("Terry Richards", "5069CEM")

customThreadExample1.data -> Hello Ian Cornelius , and welcome to 5062CEM!

customThreadExample2.data -> Hello Terry Richards, and welcome to 5069CEM!

As it stands, you have seen a variety of examples on how a function can be called, and information printed to the terminal window. However, how would you go about returning data, so it is accessible outside the thread? Well, to do this, we can create our own custom thread class by extending the Thread class from the threading module.

In this example, you can see that we have created a new class called MyThread which extends the Thread class from the threading module. You should remember from your object-orientation lectures in the first year that this is a method of inheritance, and we would inherit all functions from the Thread class itself. For example, we could call MyThread.join() and it would call the original implementation from the Thread class, even though it has not been implemented in our version of the class.

In this example, we are overriding the run() function to return a string to the data variable in the class. We are using the variables that exist in the instance of the class, name and age which have been set from the object constructor when we create the object.

When the thread is started, you can see that the outcome of each object is printed. However, it will not look any different to when we would call it without threading, as we are not doing anything too intensive on the threads.

Multithreading in Python (6)

Extending the Custom Thread Class

Extend an instance of the Thread class
Override the run function
Provide variable names with the self keyword
- add a new variable called sleep
Return the string to the self.data variable

from threading import Thread
class MyThread(Thread):
    def __init__(self, name, module, sleep):
        Thread.__init__(self)
        self.name = name
        self.module = module
        self.sleep = sleep
        self.data = None
    def run(self):
        from time import sleep
        sleep(self.sleep)
        self.data = f"Hello {self.name}, and welcome to {self.module}!"
customThreadExample1 = MyThread("Ian Cornelius ", "5062CEM", 10)
customThreadExample2 = MyThread("Terry Richards", "5069CEM", 5)
customThreadExample1.start()
customThreadExample2.start()

customThreadExample1.data -> Hello Ian Cornelius , and welcome to 5062CEM!

customThreadExample2.data -> Hello Terry Richards, and welcome to 5069CEM!

You can see in this example that I have added a sleep statement to the run function. This will create some pause, and when you run this code for yourself, you should see what happens.

Essentially, the first thread has been set to sleep for ten seconds, and the second thread has been set to sleep for five seconds. However, when we execute these threads with the start() function, followed by the join() function, we can see that when the first thread has finished executing, the data for second thread is immediately printed. This is because the second thread was executed at the same time as the first, and it finished executing before the first one had finished.

Unfortunately, we were unable to print the data to the screen until the first thread had finished executing. The purpose of this example was to demonstrate that each thread has been simultaneously executed at the same time, however, if this were a normal class, then there would be a ten-second wait, print the data, and then a further five second wait before the second batch of data was printed.

Goodbye

Goodbye (1)

Questions and Support

Questions? Post them on the Community Page on Aula
Additional Support? Visit the Module Support Page
Contact Details:
- Dr Ian Cornelius, ab6459@coventry.ac.uk