一. 课程安排

  • 课程内容
    • 线程间的资源竞争
    • 互斥锁和死锁
    • Queue线程
    • 线程同步

二. 课堂笔记

1. 线程间的资源竞争

一个线程写入,一个线程读取,没问题,如果两个线程都写入呢？

2. 互斥锁和死锁

2.1 互斥锁

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制

某个线程要更改共享数据时，先将其锁定，此时资源的状态为”锁定”,其他线程不能改变，只到该线程释放资源，将资源的状态变成”非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

  1. 创建锁
  2. mutex = threading.Lock()
  4. 锁定
  5. mutex.acquire()
  7. 解锁
  8. mutex.release()

2.2 死锁

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。

  1. import threading
  2. import time
  4. class MyThread1(threading.Thread):
  5.     def run(self):
  6.         # 对mutexA上锁
  7.         mutexA.acquire()
  9.         # mutexA上锁后，延时1秒，等待另外那个线程 把mutexB上锁
  10.         print(self.name+'----do1---up----')
  11.         time.sleep(1)
  13.         # 此时会堵塞，因为这个mutexB已经被另外的线程抢先上锁了
  14.         mutexB.acquire()
  15.         print(self.name+'----do1---down----')
  16.         mutexB.release()
  18.         # 对mutexA解锁
  19.         mutexA.release()
  21. class MyThread2(threading.Thread):
  22.     def run(self):
  23.         # 对mutexB上锁
  24.         mutexB.acquire()
  26.         # mutexB上锁后，延时1秒，等待另外那个线程 把mutexA上锁
  27.         print(self.name+'----do2---up----')
  28.         time.sleep(1)
  30.         # 此时会堵塞，因为这个mutexA已经被另外的线程抢先上锁了
  31.         mutexA.acquire()
  32.         print(self.name+'----do2---down----')
  33.         mutexA.release()
  35.         # 对mutexB解锁
  36.         mutexB.release()
  38. mutexA = threading.Lock()
  39. mutexB = threading.Lock()
  41. if __name__ == '__main__':
  42.     t1 = MyThread1()
  43.     t2 = MyThread2()
  44.     t1.start()
  45.     t2.start()

2.3 避免死锁

  • 程序设计时要尽量避免
  • 添加超时时间等

3. Queue线程

在线程中，访问一些全局变量，加锁是一个经常的过程。如果你是想把一些数据存储到某个队列中，那么Python内置了一个线程安全的模块叫做queue模块。Python中的queue模块中提供了同步的、线程安全的队列类，包括FIFO（先进先出）队列Queue，LIFO（后入先出）队列LifoQueue。这些队列都实现了锁原语（可以理解为原子操作，即要么不做，要么都做完），能够在多线程中直接使用。可以使用队列来实现线程间的同步。

  1. 初始化Queue(maxsize)：创建一个先进先出的队列。
  2. empty()：判断队列是否为空。
  3. full()：判断队列是否满了。
  4. get()：从队列中取最后一个数据。
  5. put()：将一个数据放到队列中。

4. 线程同步

天猫精灵:小爱同学

小爱同学:在

天猫精灵:现在几点了？

小爱同学：你猜猜现在几点了

5. 生产者和消费者

生产者和消费者模式是多线程开发中常见的一种模式。通过生产者和消费者模式，可以让代码达到高内聚低耦合的目标，线程管理更加方便，程序分工更加明确。
生产者的线程专门用来生产一些数据，然后存放到容器中(中间变量)。消费者在从这个中间的容器中取出数据进行消费
image.png

5.1 Lock版的生产者和消费者

  1. import threading
  2. import random
  3. gMoney = 0
  4. # 定义一个变量 保存生产的次数 默认是0次
  5. gTimes = 0
  6. # 定义一把锁
  7. gLock = threading.Lock()
  9. # 定义生产者
  10. class Producer(threading.Thread):
  12.     def run(self):
  13.         global gMoney
  14.         global gTimes
  15.         gLock.acquire()  # 上锁
  16.         while True:
  17.             # gLock.acquire() # 上锁
  18.             if gTimes >= 10:
  19.                 # gLock.release()
  20.                 break
  21.             money = random.randint(0,100)
  22.             gMoney += money
  23.             gTimes += 1
  24.             print("%s生产了%d元钱" % (threading.current_thread().name, money))
  25.         gLock.release() # 解锁
  26. # 定义消费者
  27. class Consumer(threading.Thread)
  28.     def run(self):
  29.         global gMoney
  30.         while True:
  31.             gLock.acquire()  # 上锁
  32.             money = random.randint(0, 100)
  33.             if gMoney >= money:
  34.                 gMoney -= money
  35.                 print("%s消费了%d元钱" % (threading.current_thread().name, money))
  36.             else:
  37.                 if gTimes >= 10:
  38.                     gLock.release()
  39.                     break
  40.                 print("%s想消费%d元钱，但是余额只有%d"%(threading.current_thread().name,money,gMoney))
  41.             gLock.release()  # 解锁
  43. def main():
  44.     # 开启5个生产者线程
  45.     for x in range(5):
  46.         th = Producer(name="生产者%d号" % x)
  47.         th.start()
  48.     # 开启5个消费者线程
  49.     for x in range(5):
  50.         th = Consumer(name="消费者%d号" % x)
  51.         th.start()
  53. if __name__ == '__main__':
  54.     main()

5.2 Condition版的生产者和消费者

  1. import threading
  2. import random
  3. gMoney = 0
  4. # 定义一个变量 保存生产的次数 默认是0次
  5. gTimes = 0
  6. # 定义一把锁
  7. # gLock = threading.Lock()
  8. gCond = threading.Condition()
  9. # 定义生产者
  10. class Producer(threading.Thread):
  12.     def run(self):
  13.         global gMoney
  14.         global gTimes
  16.         while True:
  17.             gCond.acquire() # 上锁
  18.             if gTimes >= 10:
  19.                 gCond.release()
  20.                 break
  21.             money = random.randint(0,100)
  22.             gMoney += money
  23.             gTimes += 1
  24.             print("%s生产了%d元钱，剩余%d元钱" % (threading.current_thread().name, money, gMoney))
  25.             gCond.notify_all()
  26.             gCond.release() # 解锁
  27. # 定义消费者
  28. class Consumer(threading.Thread):
  30.     def run(self):
  31.         global gMoney
  32.         while True:
  33.             gCond.acquire()  # 上锁
  34.             money = random.randint(0, 100)
  36.             while gMoney < money:
  37.                 if gTimes >= 10:
  38.                     gCond.release()
  39.                     return  # 这里如果用break只能退出外层循环，所以我们直接return
  40.                 print("%s想消费%d元钱，但是余额只有%d元钱了，并且生产者已经不再生产了！"%(threading.current_thread().name,money,gMoney))
  41.                 gCond.wait()
  42.             # 开始消费
  43.             gMoney -= money
  44.             print("%s消费了%d元钱，剩余%d元钱" % (threading.current_thread().name, money, gMoney))
  45.             gCond.release()
  47. def main():
  48.     # 开启5个生产者线程
  49.     for x in range(5):
  50.         th = Producer(name="生产者%d号" % x)
  51.         th.start()
  52.     # 开启5个消费者线程
  53.     for x in range(5):
  54.         th = Consumer(name="消费者%d号" % x)
  55.         th.start()
  57. if __name__ == '__main__':
  58.     main()

5.3 多线程爬虫案例