python 2中的Lock对象是否有超时?
我正在学习python中的多线程。我写了一些代码来练习python 2中的Lock对象是否有超时?,python,multithreading,Python,Multithreading,我正在学习python中的多线程。我写了一些代码来练习 import threading import time Total = 0 class myThead(threading.Thread): def __init__(self, num): threading.Thread.__init__(self) self.num = num self.lock = threading.Lock() def run(self):
import threading
import time
Total = 0
class myThead(threading.Thread):
def __init__(self, num):
threading.Thread.__init__(self)
self.num = num
self.lock = threading.Lock()
def run(self):
global Total
self.lock.acquire()
print "%s acquired" % threading.currentThread().getName()
for i in range(self.num):
Total += 1
print Total
print "%s released" % threading.currentThread().getName()
self.lock.release()
t1 = myThead(100)
t2 = myThead(100)
t1.start()
t2.start()
如果我将100传递给线程t1和t2,它们就正确了
Thread-1 acquired
100
Thread-1 released
Thread-2 acquired
200
Thread-2 released
但当我试着用更大的麻木者。例如,我通过10000。它输出意外的输出
Thread-1 acquired
Thread-2 acquired
14854
Thread-1 released
15009
Thread-2 released
我试了很多次,但都没有改变。所以我认为python中的锁对象有超时。如果锁获取时间过长,它将允许其他线程可以执行。有人能给我解释一下吗。谢谢大家! 每个线程都有自己的锁,因此获取t1的锁不会阻止t2获取自己的锁 也许您可以将
lock
设置为类属性,以便myThread
的所有实例共享一个类属性
class myThead(threading.Thread):
lock = threading.Lock()
def __init__(self, num):
threading.Thread.__init__(self)
self.num = num
结果:
Thread-1 acquired
10000
Thread-1 released
Thread-2 acquired
20000
Thread-2 released
每个线程都有自己的锁,因此获取t1的锁不会阻止t2获取自己的锁 也许您可以将
lock
设置为类属性,以便myThread
的所有实例共享一个类属性
class myThead(threading.Thread):
lock = threading.Lock()
def __init__(self, num):
threading.Thread.__init__(self)
self.num = num
结果:
Thread-1 acquired
10000
Thread-1 released
Thread-2 acquired
20000
Thread-2 released
不,锁没有超时。发生的情况是,它们实际上并没有共享同一个锁,因为每次在init方法中实例化对象时都会创建一个新的锁。如果该类的所有实例始终共享同一个锁,则可以将其作为类属性抛出。然而,显式比隐式好。我个人会将锁作为参数放在init方法中。像这样的
import threading
import time
Total = 0
class myThead(threading.Thread):
def __init__(self, num, lock):
threading.Thread.__init__(self)
self.num = num
self.lock = lock
def run(self):
global Total
self.lock.acquire()
print "%s acquired" % threading.currentThread().getName()
for i in range(self.num):
Total += 1
print Total
print "%s released" % threading.currentThread().getName()
self.lock.release()
threadLock = threading.Lock()
t1 = myThead(100, threadLock)
t2 = myThead(100, threadLock)
t1.start()
t2.start()
这样,类的两个实例共享同一个锁。不,锁没有超时。发生的情况是,它们实际上并没有共享同一个锁,因为每次在init方法中实例化对象时都会创建一个新的锁。如果该类的所有实例始终共享同一个锁,则可以将其作为类属性抛出。然而,显式比隐式好。我个人会将锁作为参数放在init方法中。像这样的
import threading
import time
Total = 0
class myThead(threading.Thread):
def __init__(self, num, lock):
threading.Thread.__init__(self)
self.num = num
self.lock = lock
def run(self):
global Total
self.lock.acquire()
print "%s acquired" % threading.currentThread().getName()
for i in range(self.num):
Total += 1
print Total
print "%s released" % threading.currentThread().getName()
self.lock.release()
threadLock = threading.Lock()
t1 = myThead(100, threadLock)
t2 = myThead(100, threadLock)
t1.start()
t2.start()
这样,类的两个实例共享同一个锁。您创建了两个独立的锁。您希望两个线程共享一个锁。您已经创建了两个独立的锁。您希望两个线程共享一个锁。我认为在我的示例中,使用class属性是最好的方法。但你的答案是另一个让它正确工作的好方法。谢谢你的帮助!我认为在我的例子中,使用class属性是最好的方法。但你的答案是另一个让它正确工作的好方法。谢谢你的帮助!