Welcome to the grand stage of Python threading, where we unravel the secrets of concurrent programming. In this performance, we will cover the threading module, share data gracefully, dance with locks to prevent race conditions, explore daemon threads, and orchestrate a harmonious experience with queues for thread-safe data processing.
Act I: Creating and Running Threads
In the opening act, we introduce the Thread class, the protagonist of our concurrent tale. Let's create and run multiple threads to unleash the power of parallelism.
from threading import Thread
def square_numbers():
for i in range(1000):
result = i * i
if __name__ == "__main__":
threads = []
num_threads = 10
for i in range(num_threads):
thread = Thread(target=square_numbers)
threads.append(thread)
for thread in threads:
thread.start()
for thread in threads:
thread.join()
Here, we've orchestrated a symphony of ten threads, each performing the noble task of squaring numbers. The start() method sets them in motion, and join() ensures the main thread waits for their triumphant completion.
Act II: Data Sharing Between Threads
Threads coexisting in the same memory space beckon us to explore data sharing. In our next act, we stage a captivating scenario where two threads gracefully interact with a shared global variable.
from threading import Thread
import time
database_value = 0
def increase():
global database_value
local_copy = database_value
local_copy += 1
time.sleep(0.1)
database_value = local_copy
if __name__ == "__main__":
print('Start value: ', database_value)
t1 = Thread(target=increase)
t2 = Thread(target=increase)
t1.start()
t2.start()
t1.join()
t2.join()
print('End value:', database_value)
print('end main')
As our threads gracefully increase the database value, we encounter a twist—a race condition. Two threads vying for the same resource lead to unexpected results. Fear not, for our hero, the Lock, steps in to bring order to this chaos.
Act III: The Lock: Guardian of Data Integrity
The plot thickens as we face the villainous race condition. In this act, the Lock emerges as our hero, preventing threads from stepping on each other's toes.
from threading import Thread, Lock
import time
database_value = 0
def increase(lock):
global database_value
lock.acquire()
local_copy = database_value
local_copy += 1
time.sleep(0.1)
database_value = local_copy
lock.release()
if __name__ == "__main__":
lock = Lock()
print('Start value: ', database_value)
t1 = Thread(target=increase, args=(lock,))
t2 = Thread(target=increase, args=(lock,))
t1.start()
t2.start()
t1.join()
t2.join()
print('End value:', database_value)
print('end main')
The Lock swoops in to save the day, ensuring that the critical code section is protected. Threads politely wait their turn, eliminating the race condition and producing the expected result.
Act IV: Daemon Threads: A Mysterious Presence
In this act, we unravel the mystery of daemon threads—background performers that gracefully exit when the main show concludes.
from threading import Thread, Lock, current_thread
from queue import Queue
def worker(q, lock):
while True:
value = q.get()
# do stuff...
with lock:
# prevent printing at the same time with this lock
print(f"in {current_thread().name} got {value}")
# For each get(), a subsequent call to task_done() tells the queue
# that the processing on this item is complete.
# If all tasks are done, q.join() can unblock
q.task_done()
if __name__ == '__main__':
q = Queue()
num_threads = 10
lock = Lock()
for i in range(num_threads):
t = Thread(name=f"Thread{i+1}", target=worker, args=(q, lock))
t.daemon = True # dies when the main thread dies
t.start()
# fill the queue with items
for x in range(20):
q.put(x)
q.join() # Blocks until all items in the queue have been gotten and processed.
print('main done')
Daemon threads cast a mysterious aura as they gracefully exit when the main performance concludes. They are the silent guardians, handling background tasks without stealing the limelight.
Grand Finale: Queues for Thread-Safe Harmony
In our grand finale, we introduce the Queue—the conductor orchestrating thread-safe data exchanges. Queues shine in both multithreaded and multiprocessing environments, ensuring a seamless flow of data.
from queue import Queue
# create queue
q = Queue()
# add elements
q.put(1) # 1
q.put(2) # 2 1
q.put(3) # 3 2 1
# now q looks like this:
# back --> 3 2 1 --> front
# get and remove the first element
first = q.get() # --> 1
print(first)
# q looks like this:
# back --> 3 2 --> front
In the multithreading spectacle, the queue takes center stage, guiding threads through a synchronized dance of data exchange. Operations on the queue are thread-safe, ensuring a flawless performance.
Our journey through the realms of Python threading concludes, leaving you equipped to compose your own symphony of concurrent elegance. May your threads dance in harmony, and your data flow seamlessly in the grand theater of parallelism.