3

我是python中的菜鸟，试图理解线程模块。我正在使用 python 2.7。python 中 with_statement 的动机之一是代码模式

with threading.Lock():
        //User defined function in a new thread

我不确定我是否理解正确，但我最初的假设是这段代码应该在主线程上获得一个锁，一旦子线程完成就会释放它。然而这个剧本

from __future__ import print_function
import threading
import time
import functools
#import contextlib
#Thread module for dealing with lower level thread operations.Thread is limited use Threading instead.

def timeit(fn):
    '''Timeit function like this doesnot work with the thread calls'''
    def wrapper(*args,**kwargs):
        start = time.time()
        fn(*args,**kwargs)
        end = time.time()
        threadID = ""
        print ("Duration for func %s :%d\n"%(fn.__name__ +"_"+ threading.current_thread().name ,end-start))
    return wrapper

exitFlag = 0

@timeit
def print_time(counter,delay):
    while counter:
        if exitFlag:
            thread.exit()
        time.sleep(delay)
        print("%s : %s_%d"%(threading.current_thread().name,time.ctime(time.time()),counter))
        counter -= 1

class Mythread(threading.Thread):
    def __init__(self,threadID,name,counter,delay):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
        self.delay = delay

    def run(self):
        print("Starting%s\n" % self.name)
        print_time(self.counter, self.delay)
        print("Exiting%s\n" % self.name)


if __name__ == '__main__':
    '''
    print_time(5, 1)
     threadLock = threading.Lock()
     threads = []
     thread1 = Mythread(1,"Thread1",5,1)
     thread2 = Mythread(2,"Thread2",5,2)
     thread1.start()
     thread2.start()
     threads.append(thread1)
     threads.append(thread2)
     for t in threads:
         t.join()
    '''
    thread1 = Mythread(1,"Thread1",5,1)
    thread2 = Mythread(2,"Thread2",5,2)
    lock = threading.Lock()
    with lock:
        thread1.start()
        thread2.start()

    print("Exiting main thread ")

产生以下输出：

StartingThread1

StartingThread2

Exiting main thread 
Thread1 : Sat May 04 02:21:54 2013_5
Thread1 : Sat May 04 02:21:55 2013_4
Thread2 : Sat May 04 02:21:55 2013_5
Thread1 : Sat May 04 02:21:56 2013_3
Thread1 : Sat May 04 02:21:57 2013_2
Thread2 : Sat May 04 02:21:57 2013_4
Thread1 : Sat May 04 02:21:58 2013_1
Duration for func print_time_Thread1 :5

ExitingThread1

Thread2 : Sat May 04 02:21:59 2013_3
Thread2 : Sat May 04 02:22:01 2013_2
Thread2 : Sat May 04 02:22:03 2013_1
Duration for func print_time_Thread2 :10

ExitingThread2

请帮助我理解为什么锁定不能与这样的 with_statement 一起使用，或者我完全误解了这个概念。我很困惑为什么即使通过定义一个锁我也会直接打印（“退出主线程”）

4

1 回答 1

12

你现有的lock基本上什么都不做。没有其他线程引用它，因此它不可能导致任何人在任何地方阻塞。它唯一可能做的就是浪费几微秒。所以这：

lock = threading.Lock()
with lock:
    thread1.start()
    thread2.start()

...几乎等同于：

time.sleep(0.001)
thread1.start()
thread2.start()

我很确定这不是你想要的。

如果您想强制线程按顺序运行，最简单的方法就是不使用线程。

或者，如果您必须使用线程，只需等待一个完成，然后再开始下一个：

thread1 = Mythread(1,"Thread1",5,1)
thread2 = Mythread(2,"Thread2",5,2)
thread1.start()
thread1.join()
thread2.start()
thread2.join()

如果你想让线程自己序列化，没有任何外部帮助，你必须给它们一个可以共享的锁。例如：

class Mythread(threading.Thread):
    def __init__(self,threadID,name,counter,delay,lock):
        threading.Thread.__init__(self)
        self.lock = lock
        # ...
    def run(self):
        with self.lock:
            # ...

现在，打电话给他们：

lock = threading.Lock()
thread1 = Mythread(1,"Thread1",5,1, lock)
thread2 = Mythread(2,"Thread2",5,2, lock)
thread1.start()
thread2.start()
# ...
thread1.join()
thread2.join()

现在，当每个线程启动时，它都会尝试获取锁。一个会成功，另一个会阻塞，直到第一个完成锁（通过退出其with语句）。

如果您不想序列化线程，您只希望主线程等待所有其他线程的完成……您所需要的只是join. 这正是join它的用途。无需添加任何其他内容。

如果你真的想要，你可以守护线程并等待同步对象。我想不出用锁来做到这一点的简单方法，但使用 aBoundedSemaphore或 a应该很容易Condition（尽管你必须等待两次条件）。但这是一件非常愚蠢的事情，所以我不确定你为什么要这样做。

于 2013-05-04T00:41:35.153 回答