29. Threading Module

This Python code snippets demonstrating the use of the threading module for implementing multi-threading in Python:

1. Basic Multi-threading

Copy

import threading

def print_numbers():
    for i in range(5):
        print(f"Thread: {threading.current_thread().name} -> {i}")

# Creating threads
thread1 = threading.Thread(target=print_numbers, name="Thread1")
thread2 = threading.Thread(target=print_numbers, name="Thread2")

thread1.start()
thread2.start()

thread1.join()
thread2.join()
print("Execution completed.")

---

2. Using Thread Class with Arguments

Copy

import threading

def print_range(start, end):
    for i in range(start, end):
        print(f"Range {start}-{end}: {i}")

thread = threading.Thread(target=print_range, args=(1, 6))
thread.start()
thread.join()

---

3. Using a Custom Thread Class

Copy

import threading

class CustomThread(threading.Thread):
    def run(self):
        for i in range(3):
            print(f"Custom thread: {self.name} -> {i}")

thread = CustomThread()
thread.start()
thread.join()

---

4. Lock for Thread Synchronization

Copy

import threading

counter = 0
lock = threading.Lock()

def increment_counter():
    global counter
    with lock:
        for _ in range(10000):
            counter += 1

threads = [threading.Thread(target=increment_counter) for _ in range(5)]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

print(f"Final Counter Value: {counter}")

---

5. Using Condition for Thread Communication

Copy

import threading

condition = threading.Condition()

def producer():
    with condition:
        print("Producing item...")
        condition.notify()

def consumer():
    with condition:
        condition.wait()
        print("Consumed item!")

thread1 = threading.Thread(target=consumer)
thread2 = threading.Thread(target=producer)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

---

6. Daemon Threads

Copy

import threading
import time

def background_task():
    while True:
        print("Daemon thread running...")
        time.sleep(1)

daemon_thread = threading.Thread(target=background_task, daemon=True)
daemon_thread.start()

time.sleep(3)
print("Main thread ends.")

---

7. Thread-safe Queue

Copy

import threading
import queue

q = queue.Queue()

def producer():
    for i in range(5):
        q.put(i)
        print(f"Produced: {i}")

def consumer():
    while not q.empty():
        item = q.get()
        print(f"Consumed: {item}")

producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)

producer_thread.start()
producer_thread.join()

consumer_thread.start()
consumer_thread.join()

---

8. Using Event for Thread Signaling

Copy

import threading

event = threading.Event()

def wait_for_event():
    print("Thread waiting for event...")
    event.wait()
    print("Event occurred!")

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

event.set()  # Trigger the event
thread.join()

---

9. Using Semaphore to Limit Threads

Copy

import threading
import time

semaphore = threading.Semaphore(2)

def limited_access_task(thread_id):
    with semaphore:
        print(f"Thread-{thread_id} acquiring semaphore")
        time.sleep(1)
        print(f"Thread-{thread_id} releasing semaphore")

threads = [threading.Thread(target=limited_access_task, args=(i,)) for i in range(5)]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

---

10. Using Barrier for Thread Coordination

Copy

import threading

barrier = threading.Barrier(3)

def wait_at_barrier(thread_id):
    print(f"Thread-{thread_id} waiting at barrier")
    barrier.wait()
    print(f"Thread-{thread_id} passed the barrier")

threads = [threading.Thread(target=wait_at_barrier, args=(i,)) for i in range(3)]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

---

These examples cover basic threading, synchronization tools (e.g., locks, semaphores, and barriers), communication tools (e.g., events and conditions), and custom thread implementations.