在Python中使用多线程将锁定机制作为全局/类作用域

Question

what is the difference between using the lock mechanism and variables as globals (outside class scope) or class variables (declared as in the question)? such as:

class httpHandler(BaseHTTPRequestHandler):
    success = 0
    fails = 0
    statsLock = threading.Lock()
    def do_POST(self):
    ...
    httpHandler.statsLock.acquire()
    httpHandler.success += 1
    self.statsLock.release()
    return

or:

success = 0
fails = 0
statsLock = threading.Lock()
class httpHandler(BaseHTTPRequestHandler):

    def do_POST(self):
    ...
    statsLock.acquire()
    success += 1
    statsLock.release()
    return

Answer 1

There isn't much of a difference. Both ways will work. Globals are however messy and dangerous so I would stay away from that.

Answer 2

Both examples are the functionally same, but you should use "global" definition of variable in second example, because you modify the global variable success and without global, local copy of the variable will be created (see this or python global documentation ).

def do_POST(self):
...
global success, fails, statsLock

statsLock.acquire()
success += 1    # THIS DOES NOT WORK WITHOUT GLOBAL
statsLock.release()
return

Anyway, I think that:

• the class scoped variables will be slightly faster because of simplified variable lookup (someone should benchmark this!).
• the global variables are more difficult to maintain because of "global" statement and because of polluting global scope.