了解多线程并锁定Python

Question

I am trying to understand the following code: What does it mean for a Thread (say Thread1) to acquire a lock, does this mean that no other method can run until Thread1 has released its lock?

import threading
import time

class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print "Starting " + self.name
        # Get lock to synchronize threads
        threadLock.acquire()
        print_time(self.name, self.counter, 3)
        # Free lock to release next thread
        threadLock.release()

def print_time(threadName, delay, counter):
    while counter:
        time.sleep(delay)
        print "%s: %s" % (threadName, time.ctime(time.time()))
        counter -= 1

threadLock = threading.Lock()
threads = []

# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# Start new Threads
thread1.start()
thread2.start()

# Add threads to thread list
threads.append(thread1)
threads.append(thread2)

# Wait for all threads to complete
for t in threads:
    t.join()

print "Exiting Main Thread"

Answer 1

A lock is a way to ensure that at most one thread at a time is executing a critical section. It is an object with two states, locked and unlocked. If it is unlocked, a call to its acquire() method locks it. If a second call to acquire() (usually by another thread) is made, this call blocks the calling thread until someone (usually the first thread) releases the lock with the release() method. Only then can the second thread continue.

In your example, the lock ensures that the thread that "gets it first" will print all lines in the print_time() function before the second thread prints anything. If you remove/comment the acquire() and release() calls, the difference should be obvious.

https://docs.python.org/2/library/threading.html#lock-objects