线程的两种调用方式

直接调用import threading import time   def sayhi(num): #定义每个线程要运行的函数       print("running on number:%s" %num)       time.sleep(3)   if __name__ == '__main__':       t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例     t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例       t1.start() #启动线程     t2.start() #启动另一个线程       print(t1.getName()) #获取线程名     print(t2.getName()) 继承式调用

import threadingimport time  class MyThread(threading.Thread):    def __init__(self,num):        threading.Thread.__init__(self)        self.num = num     def run(self):#定义每个线程要运行的函数         print("running on number:%s" %self.num)         time.sleep(3) if __name__ == '__main__':     t1 = MyThread(1)    t2 = MyThread(2)    t1.start()    t2.start()

 线程锁(互斥锁Mutex)

一个进程下可以启动多个线程，多个线程共享父进程的内存空间，也就意味着每个线程可以访问同一份数据，此时，如果2个线程同时要修改同一份数据，会出现什么状况？

import time import threading   def addNum():     global num #在每个线程中都获取这个全局变量     print('--get num:',num )     time.sleep(1)     num  -=1 #对此公共变量进行-1操作   num = 100  #设定一个共享变量 thread_list = [] for i in range(100):     t = threading.Thread(target=addNum)     t.start()     thread_list.append(t)   for t in thread_list: #等待所有线程执行完毕     t.join()     print('final num:', num )

python解释器里有一个独立的线程，每过一段时间它起wake up做一次全局轮询看看哪些内存数据是可以被清空的，此时你自己的程序 里的线程和 py解释器自己的线程是并发运行的，假设你的线程删除了一个变量，py解释器的垃圾回收线程在清空这个变量的过程中的clearing时刻，可能一个其它线程正好又重新给这个还没来及得清空的内存空间赋值了，结果就有可能新赋值的数据被删除了，为了解决类似的问题，python解释器简单粗暴的加了锁，即当一个线程运行时，其它人都不能动，这样就解决了上述的问题，  这可以说是Python早期版本的遗留问题

RLock（递归锁）

说白了就是在一个大锁中还要再包含子锁

import threading,time   def run1():     print("grab the first part data")     lock.acquire()     global num     num +=1     lock.release()     return num def run2():     print("grab the second part data")     lock.acquire()     global  num2     num2+=1     lock.release()     return num2 def run3():     lock.acquire()     res = run1()     print('--------between run1 and run2-----')     res2 = run2()     lock.release()     print(res,res2)     if __name__ == '__main__':       num,num2 = 0,0     lock = threading.RLock()     for i in range(10):         t = threading.Thread(target=run3)         t.start()   while threading.active_count() != 1:     print(threading.active_count()) else:     print('----all threads done---')     print(num,num2)

互斥锁

同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去

import threading,time   def run(n):     semaphore.acquire()     time.sleep(1)     print("run the thread: %s\n" %n)     semaphore.release()   if __name__ == '__main__':       num= 0     semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行     for i in range(20):         t = threading.Thread(target=run,args=(i,))         t.start()   while threading.active_count() != 1:     pass #print threading.active_count() else:     print('----all threads done---')     print(num)

　　

用 threading.Event 实现线程间通信

使用threading.Event可以使一个线程等待其他线程的通知，我们把这个Event传递到线程对象中，Event默认内置了一个标志，初始值为False。一旦该线程通过wait()方法进入等待状态，直到另一个线程调用该Event的set()方法将内置标志设置为True时，该Event会通知所有等待状态的线程恢复运行

通过Event来实现两个或多个线程间的交互，下面是一个红绿灯的例子，即起动一个线程做交通指挥灯，生成几个线程做车辆，车辆行驶按红灯停，绿灯行的规则。

import threading,time import random def light():     if not event.isSet():         event.set() #wait就不阻塞 #绿灯状态     count = 0     while True:         if count < 10:             print('\033[42;1m--green light on---\033[0m')         elif count <13:             print('\033[43;1m--yellow light on---\033[0m')         elif count <20:             if event.isSet():                 event.clear()             print('\033[41;1m--red light on---\033[0m')         else:             count = 0             event.set() #打开绿灯         time.sleep(1)         count +=1 def car(n):     while 1:         time.sleep(random.randrange(10))         if  event.isSet(): #绿灯             print("car [%s] is running.." % n)         else:             print("car [%s] is waiting for the red light.." %n) if __name__ == '__main__':     event = threading.Event()     Light = threading.Thread(target=light)     Light.start()     for i in range(3):         t = threading.Thread(target=car,args=(i,))         t.start()

　　

生产者消费者模型

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

为什么要使用生产者和消费者模式

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。下面来学习一个最基本的生产者消费者模型的例子

import threading import queue   def producer():     for i in range(10):         q.put("骨头 %s" % i )       print("开始等待所有的骨头被取走...")     q.join()     print("所有的骨头被取完了...")     def consumer(n):       while q.qsize() >0:           print("%s 取到" %n  , q.get())         q.task_done() #告知这个任务执行完了     q = queue.Queue()       p = threading.Thread(target=producer,) p.start()   c1 = consumer("李闯")

　　

import time,random import queue,threading q = queue.Queue() def Producer(name):   count = 0   while count <20:     time.sleep(random.randrange(3))     q.put(count)     print('Producer %s has produced %s baozi..' %(name, count))     count +=1 def Consumer(name):   count = 0   while count <20:     time.sleep(random.randrange(4))     if not q.empty():         data = q.get()         print(data)         print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name, data))     else:         print("-----no baozi anymore----")     count +=1 p1 = threading.Thread(target=Producer, args=('A',)) c1 = threading.Thread(target=Consumer, args=('B',)) p1.start() c1.start()