Analysis of misunderstandings about the use of blocking (join) and lock (Lock) in Python multi-threading

This article mainly provides details for everyone This article introduces the misunderstandings about blocking join and lock in Python multi-threading, which has certain reference value. Interested friends can refer to

About blocking the main thread

Incorrect usage of join

Thread.join() The function is to block the main thread, that is, when the child thread does not return, the main thread waits for its return and then continues execution.

join cannot be used with start in a loop
The following is the error code. The code creates 5 threads, and then uses a loop to activate the threads. After activation, it blocks the main thread.

threads = [Thread() for i in range(5)]
for thread in threads:
  thread.start()
  thread.join()

Execution process:

1. In the first loop, the main thread activates thread 1 through the start function, and thread 1 performs calculations.
2. Since the start function does not block the main thread, while thread 1 is performing operations, the main thread executes the join function downwards.
3. After executing join, the main thread is blocked by thread 1. Before thread 1 returns the result, the main thread cannot Execute the next cycle.
4. After thread 1 completes the calculation, unblock the main thread.
5. The main thread enters the next cycle, activates thread 2 and is blocked by it...

In this way, it can be seen that the five threads that were supposed to be concurrent have become sequential queues here, and the efficiency is the same as that of a single thread.

Correct usage of join

Use two loops to process the start and join functions respectively. Concurrency can be achieved.

threads = [Thread() for i in range(5)]
for thread in threads:
  thread.start()
for thread in threads:
  thread.join()

time.sleep instead of join for debugging

I have seen such code in some projects before, use time.sleep instead of join to manually block the main thread.
Before all child threads return, the main thread falls into wireless Loop and cannot exit.

for thread in threads:
  thread.start()
while 1:
  if thread_num == 0:
    break
  time.sleep(0.01)

About thread lock (threading.Lock)

Is the single-core CPU PIL still available? Need a lock?

Non-atomic operationcount = count 1 Theoretically, it is thread-unsafe.
Use 3 threads to perform the above operation at the same time to change the value of the global variable count, and check Program execution result.
If the result is correct, it means that no thread conflict has occurred.

Use the following code to test

# -*- coding: utf-8 -*-
import threading
import time
count = 0
class Counter(threading.Thread):
  def __init__(self, name):
    self.thread_name = name
    super(Counter, self).__init__(name=name)
  def run(self):
    global count
    for i in xrange(100000):
      count = count + 1
counters = [Counter('thread:%s' % i) for i in range(5)]
for counter in counters:
  counter.start()
time.sleep(5)
print 'count=%s' % count

Running result:

count=275552

In fact, the results of each run are different and incorrect, which proves that single-core CPU PIL still cannot guarantee thread safety and needs to be locked.

Correct code after locking:

# -*- coding: utf-8 -*-
import threading
import time
count = 0
lock = threading.Lock()
class Counter(threading.Thread):
  def __init__(self, name):
    self.thread_name = name
    self.lock = threading.Lock()
    super(Counter, self).__init__(name=name)
  def run(self):
    global count
    global lock
    for i in xrange(100000):
      lock.acquire()
      count = count + 1
      lock.release()


counters = [Counter('thread:%s' % i) for i in range(5)]

for counter in counters:
  counter.start()

time.sleep(5)
print 'count=%s' % count

Result:

count=500000

Pay attention to the global nature of the lock

This is a simple Python syntax issue, but it may be ignored when the logic is complex.
Ensure that the lock is suitable for multiple sub- It is shared by threads, that is, do not create locks inside subclasses of Thread.

The following is the error code

# -*- coding: utf-8 -*-

import threading
import time
count = 0
# lock = threading.Lock() # 正确的声明位置
class Counter(threading.Thread):
  def __init__(self, name):
    self.thread_name = name
    self.lock = threading.Lock() # 错误的声明位置
    super(Counter, self).__init__(name=name)
  def run(self):
    global count
    for i in xrange(100000):
      self.lock.acquire()
      count = count + 1
      self.lock.release()
counters = [Counter('thread:%s' % i) for i in range(5)]

for counter in counters:
  print counter.thread_name
  counter.start()

time.sleep(5)
print 'count=%s' % count

Related recommendations:

Detailed explanation of synchronization locks in python threads

The use of events in python multi-threading Detailed explanation

implementation of python thread pool threadpool

The above is the detailed content of Analysis of misunderstandings about the use of blocking (join) and lock (Lock) in Python multi-threading. For more information, please follow other related articles on the PHP Chinese website!