标签：线程并发 star lib int rom 多个 == error: 忘记
# encoding: UTF-8
import threading
import time
num = 0
class MyThread(threading.Thread):
def run(self):
global num
time.sleep(1)
num = num + 1
msg = self.name + ‘ set num to ‘ + str(num)
print msg + "\n"
def test():
for i in range(5):
t = MyThread()
t.start()
if __name__ == ‘__main__‘:
test()
## 输出
Thread-2 set num to 1
Thread-1 set num to 2
Thread-5 set num to 4
Thread-3 set num to 5
Thread-4 set num to 5
import threading
# 创建锁
mutex = threading.Lock()
# 申请锁
mutex.acquire(True)
# 释放锁
mutex.release()
通过Lock实现多线程同步
# encoding: UTF-8
import threading
import time
num = 0
mutex = threading.Lock() # 创建锁
class MyThread(threading.Thread):
def run(self):
global num
time.sleep(1)
if mutex.acquire(True): # 申请锁，如果没抢占到锁，会一直阻塞（block）
num = num + 1
msg = self.name + ‘ set num to ‘ + str(num)
print msg + "\n"
mutex.release() # 释放锁
def test():
for i in range(5):
t = MyThread()
t.start()
if __name__ == ‘__main__‘:
test()
## 输出
Thread-1 set num to 1
Thread-2 set num to 2
Thread-4 set num to 3
Thread-3 set num to 4
Thread-5 set num to 5
使用mutex.acquire和mutex.release显得比较繁琐，也不安全（比如编程人员忘记释放锁），可以使用with来替代。
# encoding: UTF-8
import threading
import time
class MyThread(threading.Thread):
def __init__(self, mutex):
super(MyThread, self).__init__()
self.mutex = mutex
def run(self):
global num
time.sleep(1)
with self.mutex: # with语句，安全申请和释放锁。
num = num + 1
msg = self.name + ‘ set num to ‘ + str(num)
print msg + "\n"
num = 0
mutex = threading.Lock()
def test():
for i in range(5):
t = MyThread(mutex)
t.start()
if __name__ == ‘__main__‘:
test()
Lock是不允许递归的，一个线程多次申请，将出现死锁。
import threading
lock = threading.Lock() #Lock对象
lock.acquire()
lock.acquire() #产生了死琐。
lock.release()
lock.release()
Lock\RLock这两种琐的主要区别是：
RLock允许在同一线程中被多次acquire。
而Lock却不允许这种情况。
注意：如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。
import threading
rLock = threading.RLock() #RLock对象
rLock.acquire()
rLock.acquire() #在同一线程内，程序不会堵塞。
rLock.release()
rLock.release()
信号量管理一个内部计数器，该计数器在每次acquire()调用时递减，在每次release()调用时递增。计数器永远不会低于零;当acquire()发现它为0时，它就阻塞，直到其他线程调用release()。
信号量Semaphore和互斥量mutex的最大差别是，信号量允许多个线程同时访问一个对象，而互斥量限制只能一个线程访问对象。
假如有一个连接池connection_pool维护着三个连接，如果有5个线程并发访问，则容易出现连接池没有可用连接的异常情况。例如：
# encoding: UTF-8
import threading
import time
connection_pool = [‘connection1‘, ‘connection2‘, ‘connection3‘] # 连接池
class MyThread(threading.Thread):
def __init__(self):
super(MyThread, self).__init__()
def run(self):
global connection_pool
time.sleep(1)
connection = connection_pool.pop() # 取出连接
print "get connection %s" % connection + "\n"
connection_pool.append(connection) # 放回连接
def test():
for i in range(5):
t = MyThread()
t.start()
if __name__ == ‘__main__‘:
test()
# 输出：
Exception in thread Thread-4:
Traceback (most recent call last):
File "C:\Python27\lib\threading.py", line 801, in __bootstrap_inner
self.run()
File "./with_Semaphore.py", line 17, in run
connection = connection_pool.pop()
IndexError: pop from empty list
这时，就可以使用Semaphore控制同时访问connection_pool的线程数。
# encoding: UTF-8
import threading
import time
connection_pool = [‘connection1‘, ‘connection2‘, ‘connection3‘]
semaphore = threading.Semaphore(3)
class MyThread(threading.Thread):
def __init__(self, semaphore):
super(MyThread, self).__init__()
self.semaphore = semaphore
def run(self):
global connection_pool
time.sleep(1)
with self.semaphore:
connection = connection_pool.pop()
print "get connection %s" % connection + "\n"
connection_pool.append(connection)
def test():
for i in range(5):
t = MyThread(semaphore)
t.start()
if __name__ == ‘__main__‘:
test()
# 输出：
get connection connection3
get connection connection2
get connection connection2
get connection connection2
get connection connection3
Python多线程同步Lock\RLock\Semaphore
标签：线程并发 star lib int rom 多个 == error: 忘记
原文地址：https://www.cnblogs.com/cnwenf/p/12790435.html
