Introduction to Multithreading in Python
Tags: python, multithreading, worker, locking
Published: 2023-02-11 03:23:01

Multithreading is a process of executing multiple threads (small units of a program) concurrently within a single process. This can greatly improve the performance of your program, as multiple threads can run simultaneously and make efficient use of the available processing power.

In Python, multithreading is achieved using the `threading` module. In this module, the `Thread` class represents a thread of execution, and provides a simple way to create and run threads in your program.

## A Simple Example
Here's a simple example that demonstrates the basic usage of the `threading` module:

```python
import time
import threading

def worker():
    print("Worker thread started")
    time.sleep(1)
    print("Worker thread finished")

thread = threading.Thread(target=worker)
thread.start()

print("Main thread finished")

```
In this example, we define a function `worker` that simply prints a message and then sleeps for 1 second. We then create a `Thread` object, passing `worker` as the target function to be executed by the thread. Finally, we start the thread using the `start` method.

When you run this program, you'll see that the `Worker thread started` and `Worker thread` finished messages are printed interleaved with the `Main thread finished` message, as both threads run concurrently.


## Sharing Data between Threads
In some cases, you may want to share data between threads. One simple way to do this is to use a global variable, like this:

```python
import time
import threading

counter = 0

def worker():
    global counter
    print("Worker thread started")
    for i in range(100000):
        counter += 1
    print("Worker thread finished")

thread = threading.Thread(target=worker)
thread.start()

time.sleep(1)

print("Counter value:", counter)
print("Main thread finished")

```
In this example, we define a global variable `counter` that is incremented by the `worker` thread. When the `Main` thread finishes, it prints the final value of `counter`, showing that the two threads have shared access to the same data.


## Locking
However, be careful when sharing data between threads, as this can easily lead to race conditions, where multiple threads try to access and modify the same data simultaneously, leading to unpredictable results. To avoid this, you can use locks to synchronize access to shared data, like this:

```python
import time
import threading

counter = 0
lock = threading.Lock()

def worker():
    global counter
    print("Worker thread started")
    for i in range(100000):
        with lock:
            counter += 1
    print("Worker thread finished")

thread = threading.Thread(target=worker)
thread.start()

time.sleep(1)

print("Counter value:", counter)
print("Main thread finished")

```
In this example, we use a `Lock` object to synchronize access to the shared `counter` variable. The `with` statement ensures that the lock is acquired before the variable is modified, and released after the modification is complete. This ensures that only one thread can access the variable.

To Learn More About Python Multithreading: [Click Here](https://docs.python.org/3/library/threading.html)
Connect with me: [Linkedin](https://www.linkedin.com/in/noyonict/)