- Data Structures & Algorithms - [Link](https://github.com/animator/learn-python/tree/main/contrib/ds-algorithms) **(Not accepting)**

- [Threading](threading.md)

Threading is a sequence of instructions in a program that can be executed independently of the remaining process and

Threads are like lightweight processes that share the same memory space but can execute independently.

The process is an executable instance of a computer program.

This guide provides an overview of the threading module and its key functionalities.

* Shared Memory: All threads within a process share the same memory space, which allows for efficient communication between threads.

* Independent Execution: Each thread can run independently and concurrently.

* Context Switching: The operating system can switch between threads, enabling concurrent execution.

This module will allows you to create and manage threads easily. This module includes several functions and classes to work with threads.

**1. Creating Thread:**

To create a thread in Python, you can use the Thread class from the threading module.

Example:

import threading

thread = threading.Thread()

thread.start()

thread.join()

print("Thread has finished execution.")

Output :

**2. Performing Task with Thread:**

We can also perform a specific task by thread by giving a function as target and its argument as arg ,as a parameter to Thread object.

Example:

import threading

def print_numbers(arg):

for i in range(arg):

print(f"Thread: {i}")

thread = threading.Thread(target=print_numbers,args=(5,))

thread.start()

thread.join()

print("Thread has finished execution.")

Output :

**3. Delaying a Task with Thread's Timer Function:**

We can set a time for which we want a thread to start. Timer function takes 4 arguments (interval,function,args,kwargs).

Example:

import threading

def print_numbers(arg):

for i in range(arg):

print(f"Thread: {i}")

thread = threading.Timer(3,print_numbers,args=(5,))

thread.start()

thread.join()

print("Thread has finished execution.")

Output :

**4. Creating Multiple Threads**

We can create and manage multiple threads to achieve concurrent execution.

Example:

```python

import threading

def print_numbers(thread_name):

for i in range(5):

print(f"{thread_name}: {i}")

thread1 = threading.Thread(target=print_numbers, args=("Thread 1",))

thread2 = threading.Thread(target=print_numbers, args=("Thread 2",))

thread1.start()

thread2.start()

thread1.join()

thread2.join()

print("Both threads have finished execution.")

Output :

**5. Thread Synchronization**

When we create multiple threads and they access shared resources, there is a risk of race conditions and data corruption. To prevent this, you can use synchronization primitives such as locks.

A lock is a synchronization primitive that ensures that only one thread can access a shared resource at a time.

Example:

import threading

lock = threading.Lock()

def print_numbers(thread_name):

for i in range(10):

with lock:

print(f"{thread_name}: {i}")

thread1 = threading.Thread(target=print_numbers, args=("Thread 1",))

thread2 = threading.Thread(target=print_numbers, args=("Thread 2",))

thread1.start()

thread2.start()

thread1.join()

thread2.join()

print("Both threads have finished execution.")

Output :

A ```lock``` object is created using threading.Lock() and The ```with lock``` statement ensures that the lock is acquired before printing and released after printing. This prevents other threads from accessing the print statement simultaneously.

Threading in Python is a powerful tool for achieving concurrency and improving the performance of I/O-bound tasks. By understanding and implementing threads using the threading module, you can enhance the efficiency of your programs. To prevent race situations and maintain data integrity, keep in mind that thread synchronization must be properly managed.