文章目录
一、基础概念
①并发： 系统在一段时间内，处理多个任务的能力
②并行： 系统在同一时刻，处理多个任务的能力
③同步： 当进程执行到一个IO（等待外部数据）的时候，等待，不继续向下运行。
④异步： 当进程执行到一个IO（等待外部数据）的时候，不等待，而是先执行其他代码，一直到数据接收成功，再回来处理。
⑤GIL： 全局解释锁。同一时刻，在同一进程下，如果有多个线程，但CPU只能执行其中一个。
⑥任务分两种： IO密集型和计算密集型。
对于IO密集型的任务，python的多线程可以加快速度，可以采用多进程+协程处理。
对于计算密集型的任务，python的多线程反而因为切换的开销，增加处理时间。
二、同步锁
同步锁也叫互斥锁
（1）未加同步锁情形
import threading
import time
def sub():
global num
temp = num
time.sleep(0.001)
num = temp -1
num = 100
l = []
for i in range(100):
t = threading.Thread(target=sub)
t.start()
l.append(t)
for t in l:
t.join()
print(num) # 98 输出结果不确定
上述代码中，各个线程在时间片轮转时，自己可能还没执行完，造成num值还未改变，就切换到其他线程了。所以num的值输出不固定（取决于cpu的执行速度）
（2）加同步锁情形
import threading
import time
def sub():
global num
lock.acquire() # 申请同步锁
temp = num
time.sleep(0.001)
num = temp - 1
lock.release() # 释放同步锁
num = 100
l = []
lock = threading.Lock() # 创建同步锁对象
for i in range(100):
t = threading.Thread(target=sub)
t.start()
l.append(t)
for t in l:
t.join()
print(num) # 0
在执行 lock.acquire() 后，线程不允许被切换，在执行 lock.release() 后，才允许切换线程。
三、线程死锁和递归锁
在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。这两个线程在无外力作用下将一直等待下去。例：
import threading
import time
class MyThread(threading.Thread):
def actionA(self):
A.acquire()
print(self.name,"actionA gotA",time.strftime("%X"))
time.sleep(1)
B.acquire()
print(self.name, "actionA gotB", time.strftime("%X"))
time.sleep(1)
B.release()
A.release()
def actionB(self):
B.acquire()
print(self.name, "actionB gotB", time.strftime("%X"))
time.sleep(1)
A.acquire()
print(self.name, "actionB gotA", time.strftime("%X"))
time.sleep(1)
A.release()
B.release()
def run(self):
self.actionA()
self.actionB()
if __name__ == '__main__':
A = threading.Lock()
B = threading.Lock()
L = []
for i in range(3):
t = MyThread()
t.start()
L.append(t)
for i in L:
i.join()
print("ending...")
第一个线程在执行完actionA方法的B.release()时，第二个线程开始执行actionA方法的A.acquire()。然后两个线程并发运行，直到第一个线程执行actionB方法的A.acquire()，第二个线程执行actionA方法的B.acquire，形成死锁。
解决方法——递归锁
递归锁可以看成有个计数器默认count=0，执行acquire时，count+1；执行release时，count-1。只有当count=0时，才允许新的线程执行acquire后续语句。
import threading
import time
class MyThread(threading.Thread):
def actionA(self):
r_lock.acquire() # count=1
print(self.name,"actionA gotA",time.strftime("%X"))
time.sleep(1)
r_lock.acquire() # count=2
print(self.name, "actionA gotB", time.strftime("%X"))
time.sleep(1)
r_lock.release() # count=1
r_lock.release() # count=0
def actionB(self):
r_lock.acquire()
print(self.name, "actionB gotB", time.strftime("%X"))
time.sleep(1)
r_lock.acquire()
print(self.name, "actionB gotA", time.strftime("%X"))
time.sleep(1)
r_lock.release()
r_lock.release()
def run(self):
self.actionA()
self.actionB()
if __name__ == '__main__':
r_lock = threading.RLock()
L = []
for i in range(3):
t = MyThread()
t.start()
L.append(t)
for i in L:
i.join()
print("ending...")
四、同步条件（event）
event是一个简单的同步对象。
event可以使两个线程同步。
event = threading.Event() 创建同步条件对象
执行event.wait()的线程将等待flag被设定，而阻塞。event.set() 设定flag。当flag被设定的时候，执行event.wait()的线程将不被阻塞，相当于pass。当执行event.clear()，flag将被清除，event.wait()将继续阻塞。多个线程可以等候同一个event对象。
import threading,time
class Boss(threading.Thread):
def run(self):
print("BOSS：今晚大家都要加班到22:00。")
print("first:",event.isSet())# False
event.set()
time.sleep(3)
print("BOSS：<22:00>可以下班了。")
print("second:",event.isSet()) # False
event.set()
class Worker(threading.Thread):
def run(self):
event.wait()# 一旦flag被设定，event等同于pass
print("Worker：哎……命苦啊！")
time.sleep(1)
event.clear()
event.wait()
print("Worker：OhYeah!")
if __name__=="__main__":
event=threading.Event()
threads=[]
for i in range(5):
threads.append(Worker())
threads.append(Boss())
for t in threads:
t.start()
for t in threads:
t.join()
print("ending.....")
五、信号量
Semaphore(count)设定一个计数器count，然后每执行acquire()时，count-1，执行release()时，count+1。当count=0时，再执行acquire()将阻塞线程。相当于同步锁的一个扩展，同步锁的count最大等于1.。
import threading,time
class myThread(threading.Thread):
def run(self):
if semaphore.acquire(): # 允许5个线程同时进
print(self.name)
time.sleep(2)
semaphore.release() # 5个线程同时释放锁
if __name__=="__main__":
semaphore=threading.Semaphore(5) # 相当于申请了5把锁
thrs=[]
for i in range(100):
thrs.append(myThread())
for t in thrs:
t.start()
六、线程队列（queue）
同一个进程下的多个线程，共享该queue数据
1、常用方法
put(item)： 在队列队尾插入一个item。其参数block默认为True，如果队列已满，将阻塞线程。设置block=False，队列已满，将不会阻塞线程，而是引发Full异常。
get()： 将一个值从队列中取出，其参数block默认为True，如果队列已空，将阻塞线程。设置block=False，队列已空，将不会阻塞线程，而是引发Empty异常。
qsize()： 返回队列大小（实际存储数据的个数）
empty()： 如果队列为空，返回True，反之False
full()： 如果队列已满，返回True，反之False
full： 与maxsize大小对应
get_nowait()： 相当于get(block=False)
**put_nowait(item)：**相当于put(item,block=False)
task_done() 和 join()： 每当向队列中put()一个item时，未完成任务的计数unfinished_tasks就会加1。调用一次task_done()，unfinished_tasks会减1：
当unfinished_tasks=0时，join()相当于pass。
当unfinished_tasks>0时，join()会阻塞线程。
当调用task_done()次数多于put()时，会引发异常ValueError: task_done() called too many times
2、queue模块的三种模式
（1）FIFO队列
先进先出
import queue
q = queue.Queue(3) # FIFO模式
# Queue(maxsize)的参数maxsize为队列最大长度，缺省，则队列长度无限长。
q.put(12)
q.put("hello")
q.put({"age":18})
while True:
data = q.get()
print(data)
print("---------")
'''
12
---------
hello
---------
{'age': 18}
---------
'''
（2）LIFO队列
后进先出，类似于栈
import queue
q = queue.LifoQueue() # LIFO模式
q.put(12)
q.put("hello")
q.put({"age":18})
while True:
data = q.get()
print(data)
print("---------")
'''
{'age': 18}
---------
hello
---------
12
---------
'''
（3）按优先级
设置优先级数字越小，越先出来
import queue
q = queue.PriorityQueue() # 按优先级模式
q.put([3,12])
q.put([2,"hello"])
q.put([4, {"age": 18}])
while True:
data = q.get()
print(data)
print("---------")
'''
[2, 'hello']
---------
[3, 12]
---------
[4, {'age': 18}]
---------
'''
七、生产者消费者模型
生产数据的线程就是生产者，消费数据的线程就是消费者。为了解决生产者生产速度和消费者消费数据速度不均衡的问题，需要引入一个阻塞队列作为缓冲区。
import threading, queue
import time
def consumer(q):
while True:
item = q.get()
print(f"Consume {item}\n",end="")
time.sleep(1)
q.task_done()
def producer(q):
for i in range(10):
q.put(i)
print("in production...\n", end="")
q.join()
print("finish!\n",end="")
q = queue.Queue()
t1 = threading.Thread(target=consumer, args=(q,),daemon=True)
t2 = threading.Thread(target=consumer, args=(q,),daemon=True)
t1.start()
t2.start()
producer(q)
print("end")
268
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
