python第五十一天----线程,Event,队列

进程与线程的区别:

线程==指令集，进程==资源集  （线程集）

1、同一个进程中的线程共享内存空间,进程与进程之间是独立的

2、同一个进程中的线程是可以直接通讯交流的，进程与间通讯必需通过一个中间的代理才能实现

3、创建线程简单，创建进程，是克隆父进程

4、一个线程可以控制和操作同一进程里的其他线程，但进程只能操作子进程

5、线程启动速度快，进程启动速度比较慢

线程示例：

 import time ,threading

 def run(attr):
     print('输出:',attr)
     time.sleep(3)

 t1=threading.Thread(target=run,args=('第一个线程',))
 t2=threading.Thread(target=run,args=('第二个线程',))

 t1.start()#启动线程1
 t2.start()#启动线程2

 def run2(attr):
     print('输出:',attr)
     time.sleep(3)

 run2('第一个线程')
 run2('第二个线程')
 #以上转为串联执行

继承线程 类写线程

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan

 import threading,time

 class thre(threading.Thread):#继承线程中的类
     def __init__(self,n,times):
         super(thre,self).__init__()
         self.n=n
         self.teims=times
     def run(self):
         print('执行第一线程:',self.n)
         time.sleep(self.teims)

 star_time=time.time()
 t1=thre('第一线程',3)
 t2=thre('第二线程',4)
 t1.start()
 t2.start()
 t1.join()#join等待该线程执行完成

 t2.join()
 den_time=time.time()-star_time
 print(den_time)

等待线程执行完成，用.join

 import time ,threading
 lock=threading.Lock()#定义一个线程锁变量
 def run(attr):
     lock.acquire()#申请一个线程锁
     global num
     print('输出:',attr)
     #time.sleep(3)
     num+=1
     lock.release()#释放线程锁
     time.sleep(3)
     print('输出完成'.center(10,'〓'))
 star_time=time.time()#开始时间

 num=0
 re_lilst=[]#定义一个列表
 for i in range(50):
     t1=threading.Thread(target=run,args=(('第%s线程'%i),))#新建线程
     #t1.setDaemon(True)#设置为守护进程 当主线程完成,守护也停止
     t1.start()#起动线程
     re_lilst.append(t1)#不用JOIN,避免阻塞为串行

 print(threading.current_thread(),threading.active_count())#查看线程 的主 子  活跃线程
     #print('分线程'.center(40,'☆'))
 print('数字:',num)
 for i in re_lilst:#等待线程 完成
     i.join()
 print('数字:',num)
 print('主线程'.center(60,'◇'),threading.current_thread(),threading.active_count())

 den_time=time.time()-star_time#总共时间
 print(den_time)

守护进程，相当于主进程的下属，当主进程结束，无论守护进程内的是否执行完成，都会停止！

 import time ,threading
 lock=threading.Lock()#定义一个线程锁变量
 def run(attr):
     lock.acquire()#申请一个线程锁
     global num
     print('输出:',attr)

     #time.sleep(3)
     num+=1
     lock.release()#释放线程锁
     time.sleep(3)
     print('输出完成'.center(10,'〓'))

 star_time=time.time()#开始时间

 num=0
 re_lilst=[]#定义一个列表
 for i in range(50):
     t1=threading.Thread(target=run,args=(('第%s线程'%i),))#新建线程
     t1.setDaemon(True)#设置为守护进程 当主线程完成,守护也停止
     t1.start()#起动线程
     re_lilst.append(t1)#不用JOIN,避免阻塞为串行

 print(threading.current_thread(),threading.active_count())#查看线程 的主 子  活跃线程
     #print('分线程'.center(40,'☆'))
 print('数字:',num)
 # for i in re_lilst:#等待线程 完成
 #    i.join()
 print('数字:',num)
 print('主线程'.center(60,'◇'),threading.current_thread(),threading.active_count())

 den_time=time.time()-star_time#总共时间
 print(den_time)

线程锁，在py3中可以不使用：

lock=threading.Lock()

lock.acquire()

递归锁  用于递归线程

 import time ,threading

 def run(i):
     print('输出:-------',i)
     lock.acquire()#申请锁
     global num1
     num1+=1
     time.sleep(0.1)
     lock.release()#释放锁
     return num1

 def run2(i):
     lock.acquire()#申请锁
     global num2
     print('输出:22',i)
     num2+=1
     time.sleep(0.1)
     lock.release()#释放锁
     return num2

 def run3(i):
     lock.acquire()#申请锁
     res=run(i)
     print('输出:333',i)
     res2=run2(i)
     time.sleep(0.1)
     print(res,res2)
     lock.release()#释放锁

 if __name__ == '__main__':
     star_time=time.time()#开始时间\
     num1,num2=0,0
     #lock=threading.Lock()#定义一个线程锁,如是线程锁,递归时会出错
     lock=threading.RLock()#定义一个递归锁

     for i in range(10):
         #t1=threading.Thread(target=run,args=(('第%s线程'%i),))#新建线程
         t1=threading.Thread(target=run3,args=(('第%s线程'%i),))#新建线程
         t1.start()#起动线程

     else:
         print('活跃线程数:',threading.active_count())#查看线程 活跃线程数

 while threading.active_count()!=1:#不只一个线程,就是说,判断是否是剩下主线程
     #print(threading.active_count())#查看线程 活跃线程数
     pass
 else:
     print('主线程:pid,活跃线程数'.center(60,'◇'),threading.current_thread(),threading.active_count())#
     den_time=time.time()-star_time#总共时间
     print(den_time)
     print(num1,num2)

信号量  相当与 多个线程锁

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan
 import time ,threading

 def run(attr):
     semaphore.acquire()#申请信号量线程锁
     global num
     print('输出:',attr)
     time.sleep(1)
     semaphore.release()#释放信号量线程锁

 star_time=time.time()#开始时间
 if __name__ == '__main__':

     semaphore=threading.BoundedSemaphore(4)#信号量 最多允许几个线程同时运行(多把锁)
     for i in range(50):
         t1=threading.Thread(target=run,args=(('第%s线程'%i),))#新建线程
         t1.start()#起动线程

 while threading.active_count()!=1:#不只一个线程,就是说,判断是否是剩下主线程
     pass
 else:
     print('主线程'.center(60,'◇'),threading.current_thread(),threading.active_count())
     den_time=time.time()-star_time#总共时间
     print(den_time)

Event 线程标志

红绿灯示例

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan

 import threading,time

 event=threading.Event()#生成一个标示位对象
 def lighter():#
     count=0 #定义时间秒数
     event.set()#设置标志位
     while True:
         if count>9 and count<15:#设定为红灯
             event.clear()#清除标志位,
             print('\033[41;1m变为红灯!\033[0m')
         elif count>=15 and count<18 :#为黄灯

             print('\033[43;1m变为黄灯!\033[0m')
         elif count>=18:
             event.set()#设置标志位
             print('\033[42;1m变为绿灯!\033[0m')
             count=0#重新计时
         else:
             print('\033[42;1m绿灯中.....!\033[0m')
         time.sleep(1)
         count+=1#每一秒钟加一次

 def car(name):
     while True:
         if event.is_set():#如果有标志 说明为绿灯
             print('[%s]在行驶中....'%name)
             time.sleep(1)
         else:
             print('[%s]在等待中.....'%name)
             event.wait()#等待获取标志
             print('绿灯亮了,[%s]继续行驶...'%name)
             time.sleep(1)

 light=threading.Thread(target=lighter,)#定义一个线程
 light.start()#启动线程

 car1=threading.Thread(target=car,args=('红旗轿车',))#生成一个汽车线程
 car1.start()

队列  生产者消费者模型

 #！usr/bin/env python
 #-*-coding:utf-8-*-
 # Author calmyan

 #队列 生产者消费者模型

 import threading,time,queue

 q=queue.Queue()#创建一个队列

 def produ(name):#生产函数
     count=0
     while True:
         bz=name+str(count)
         q.put(bz)
         print('[%s]生产了,第[%s]个[%s]g 包子'%(name,count,bz))
         count+=1
         time.sleep(1.5)

 def consump(name):#消费者
     while True:
         i=q.get()#取
         print('[%s]拿到包子[%s],并吃了'%(name,i))
         time.sleep(0.5)

 p1=threading.Thread(target=produ,args=('王五包子铺',))#创建一个新线程 生产者
 p2=threading.Thread(target=produ,args=('麻子六包子铺',))#创建一个新线程 生产者
 r1=threading.Thread(target=consump,args=('张三',))#创建一个新线程 消费者
 r2=threading.Thread(target=consump,args=('李四',))#创建一个新线程 消费者
 p1.start()
 p2.start()
 r1.start()
 r2.start()