1.Queue的说明

  • 1.对于Queue，在多线程通信之间扮演重要的角色
  • 2.添加数据到队列中，使用put()方法
  • 3.从队列中取数据，使用get()方法
  • 4.判断队列中是否还有数据，使用qsize()方法

2.生产者消费者模式的说明

  • 使用生产者和消费者模式的原因在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。
  • 生产者消费者模式生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。

ThreadLocal

在多线程环境下，每个线程都有自己的数据。一个线程使用自己的局部变量比使用全局变量好，因为局部变量只有线程自己能看见，不会影响其他线程，而全局变量的修改必须加锁。

1.使用函数传参的方法

  1. def process_student(name):
  2.     std = Student(name)
  3.     # std是局部变量，但是每个函数都要用它，因此必须传进去：
  4.     do_task_1(std)
  5.     do_task_2(std)
  8. def do_task_1(std):
  9.     do_subtask_1(std)
  10.     do_subtask_2(std)
  13. def do_task_2(std):
  14.     do_subtask_2(std)
  15.     do_subtask_2(std)

说明：用局部变量也有问题，因为每个线程处理不同的Student对象，不能共享。

2.使用全局字典的方法

  1. import threading
  4. # 创建字典对象:
  5. myDict={}
  8. def process_student():
  9.     # 获取当前线程关联的student:
  10.     std = myDict[threading.current_thread()]
  11.     print('Hello, %s (in %s)' % (std, threading.current_thread().name))
  14. def process_thread(name):
  15.     # 绑定ThreadLocal的student:
  16.     myDict[threading.current_thread()] = name
  17.     process_student()
  20. t1 = threading.Thread(target=process_thread, args=('yongGe',), name='Thread-A')
  21. t2 = threading.Thread(target=process_thread, args=('老王',), name='Thread-B')
  22. t1.start()
  23. t2.start()

运行结果;

  1. Hello, yongGe (in Thread-A)
  2. Hello, 老王 (in Thread-B)

这种方式理论上是可行的，它最大的优点是消除了std对象在每层函数中的传递问题，但是，每个函数获取std的代码有点low。

3.使用ThreadLocal的方法

  1. import threading
  4. # 创建全局ThreadLocal对象:
  5. local_school = threading.local()
  6. def process_student():
  7.     # 获取当前线程关联的student:
  8.     std = local_school.student
  9.     print('Hello, %s (in %s)' % (std, threading.current_thread().name))
  12. def process_thread(name):
  13.     # 绑定ThreadLocal的student:
  14.     local_school.student = name
  15.     process_student()
  18. t1 = threading.Thread(target=process_thread, args=('erererbai',), name='Thread-A')
  19. t2 = threading.Thread(target=process_thread, args=('老王',), name='Thread-B')
  20. t1.start()
  21. t2.start()

运行结果：

  1. Hello, erererbai (in Thread-A)
  2. Hello, 老王 (in Thread-B)

说明：

全局变量local_school就是一个ThreadLocal对象，每个Thread对它都可以读写student属性，但互不影响。你可以把local_school看成全局变量，但每个属性如local_school.student都是线程的局部变量，可以任意读写而互不干扰，也不用管理锁的问题，ThreadLocal内部会处理。 可以理解为全局变量local_school是一个dict，不但可以用local_school.student，还可以绑定其他变量，如local_school.teacher等等。

  • ThreadLocal最常用的地方就是为每个线程绑定一个数据库连接，HTTP请求，用户身份信息等，这样一个线程的所有调用到的处理函数都可以非常方便地访问这些资源。

一个ThreadLocal变量虽然是全局变量，但每个线程都只能读写自己线程的独立副本，互不干扰。ThreadLocal解决了参数在一个线程中各个函数之间互相传递的问题。