我是否必须为多线程锁定所有调用一个或多个锁定函数的函数？

Question

好的，我一直在 this article 阅读 python 中有关以正确方式锁定重要语句的内容。

例子是

lock = threading.Lock()



def get_first_part():

    lock.acquire()

    try:

        ... fetch data for first part from shared object

    finally:

        lock.release()

    return data



def get_second_part():

    lock.acquire()

    try:

        ... fetch data for second part from shared object

    finally:

        lock.release()

    return data

def get_both_parts():

    lock.acquire()

    try:

        first = get_first_part()

        second = get_second_part()

    finally:

        lock.release() # The finally block will alway execute no mater what before this, not matter return/break/continue. https://docs.python.org/2/tutorial/errors.html

    return first, second

所以这是我的问题，我有一个串行设备控件class，其中的每个函数都调用了重要的语句（函数需要线程锁（RLock））。

有些函数只调用 get_first_part()，有些函数同时调用两者，有些更复杂，可能会调用 first、second、third、first 等。

所以我的问题是我是否必须在 class 中的每个此类函数中放置 lock.aquire() 和 release ？锁定和释放所有这些功能的首选方法是什么？使用装饰器 ?

谢谢。

Answer 1

with 语句更好：

lock = threading.RLock()

def get_first_part():
    with lock:
        return ...data for first part...

等等等等

是的，当然，您可以根据需要使用装饰器：

import functools

def withlock(func):
    @functools.wrap(func)
    def wrapper(*a, **k):
        with lock:
            return func(*a, **k)
    return wrapper

然后

@withlock
def get_first_part():
    return ...data for first part...

但是，所有函数的整个主体都需要始终持有锁是不寻常的，with 语句让您可以更好地了解哪些部分确实需要该锁（任何准备和 post-处理可以发生在获取锁之前和释放锁之后）。因此，在这种情况下，我通常会使用优雅的 with，而不是使用装饰器的 "gross grained" 方法。

我是否必须为多线程锁定所有调用一个或多个锁定函数的函数？

Do I have to lock all functions that calls to one or more locked function for multi-threading?

python

multithreading

locking