Lock对多线程执行效率的影响

假定有$n$个线程执行同一段代码，如果不需要使用lock保护并发操作，则每个线程完成代码执行的时间理论上是相同的，假定为$t$。假设整个任务需要重复执行上述代码$m$次，$n \leq t$，则理论上该任务的执行时间为 $T_{0} = (k+1) \cdot t$（$l>0$）或$k \cdot t$（$l=0$），其中$m = k \cdot n + l$。如果每个线程独占一个CPU核心，则线程执行过程如图1所示。

图1 无lock的多线程执行过程
如果代码执行过程中需要lock保护，线程一开始执行就需要获取lock，线程执行过程如图2所示，其中被lock的代码执行时间为 $p$。整个任务执行时间为$T_{lock}=k[t+(n-1)p]+[t + (l-1) \cdot p]$。

图2 有lock的多线程执行过程
假设 $l > 0$，则 $T_{lock}$和 $T$的差为：
$$T_{lock}-T = [k(n-1)+l-1]p \approx k(n-1)p$$
在CPU核心确定的情况下，即 $n$取定的情况下，线程重复执行代码的次数$k$愈多，需要lock保护的代码执行时间 $p$越长，则带lock的多线程执行时间就越长。由于任务是确定的，即$k$确定，因此，为了提升程序效率，一般需要尽量减少 p<script type="math/tex">p</script>，即尽量减少需要lock保护的代码。
下面的python代码可以用来对比实际执行时间，无lock保护的执行时间是9.827271938323975，带lock保护的执行时间是13.370273351669312。

import threading
import time

queue = [i for i in range(20)]
NUM_THREAD = 4
locker = threading.Lock()


def execute_task():
    global queue, locker
    while queue:
        n = 0
        # locker.acquire()
        for i in range(1000000):
            n += i * i
        if queue:
            queue.pop()
        # locker.release()
        n = 0
        for i in range(1000000):
            n += n * (n + i)

start_time = time.time()
for i in range(NUM_THREAD):
    th = threading.Thread(target=execute_task)
    th.start()
while queue:
    pass
elapsed_time = time.time() - start_time
print(elapsed_time)