python3.x Day6 多线程
线程？？？进程？？？？区别？？？何时使用？？？
进程：是程序以一个整体的形式暴露给操作系统管理，里边包含了对各种资源的调用，内存的使用，对各种资源的管理的集合，这就叫进程
线程：是操作系统最小的调度单位，是一串指令的集合。
进程要操作CPU，必须要先创建一个线程，所以，只有进程，没有线程，进程是执行不了的。
所有在同一个进程内的线程是共享同一块内存空间，
进程 VS 线程：
1、线程共享内存空间，进程的内存是独立的
2、多线程操作数据资源时，数据资源是同一份共享的，多进程是独享一份数资源的，出现子进程也是克隆份数据资源给子进程
3、同一个进程的线程之间可以直接交流，进程就独立了，进程之间需要交流，必须有通过一个中间代理实现。
4、创建新的线程很简单，创建新进程需要对其父进程进行一次克隆
5、一个线程可以控制同一进程里的其他线程， 进程只能操作子进程
6、对于主线程的修改，有可能会影响到其他线程运行行为，对于父进程的修改，不会影响子进程
何时用多线程：
IO操作不占用CPU，计算占用CPU
python多线程不适合CPU密集操作型的任务，适合IO密集型的任务。
import threading import time,random m=random.Random() def task(name,sleep_time): print("任务：%s"%name,threading.current_thread(),threading.active_count()) time.sleep(sleep_time) print("任务 %s 运行结束"%name,threading.active_count()) thread_list=[] start_time=time.time() for i in range(50): t=threading.Thread(target=task,args=("task"+str(i),m.randint(1,4))) t.setDaemon(True) #这就是把当前线程设定为守护线程，必须在start()之前。 # 守护线程：是守护主线程的仆人，主线程的执行不再等待子线程的结束，但是主线程一旦结束退出，所有守护线程会被强制退出 t.start() thread_list.append(t) print("当前活跃的线程数：%s"%threading.active_count()) #等待线程结束不要等待守护线程，因为没有意义 # for t in thread_list: # t.join() #这是主线程等待一个线程完成以后 print("all time:%s"%(time.time()-start_time),threading.current_thread(),threading.active_count())
线程锁 + 信号量
import threading,time,random m=0 lock=threading.Lock() #线程排它锁 def upup(): global m,lock lock.acquire() #加锁，如果不加锁，在py2.x时，由于执行获取gil锁仅与CPU指令和CPU时间片段有关，这样加锁，同一时间仅有一个线程可以执行该函数 # 可能导致线程在修改数据时拿到的不是其他线程修改完的数据，而是CPU寄存器中的数据， # 再去进行修改，然后重新赋值，这样最终结果就不正确了。而且不可控制。 # py3.x没有这个问题,但是官方没有声明，所以还是需要加锁的。 m+=1 lock.release() print("num is %s"%m) time.sleep(1) #释放锁 #锁住数据以后，其他线程在获取锁资源之前，是无法修改该数据的，这么一来，被加锁的代码段将会是串行的， # 所以，原则上，被加锁的代码段尽量要短并且效率高 for i in range(50): # m=upup(m) t=threading.Thread(target=upup) t.start() # for i in range(50): # m=upup(m) print("m 最后是:%s"%m) # 递归锁：还有一种情况，就是函数之间存在调用，每个函数又都需要线程排它锁，因为锁的定义就是一个全局的， # 此时程序运行时，当开始了函数中调用的函数的锁以后，该线程获取到两把锁对应两个函数， # 这时，被函数调用的函数执行完成以后，是无法释放线程排它锁的，原因就是进行操作的线程不知道手里的钥匙是哪个锁的，就出不来了，其实是被排他了。 # 这样的情况下，诞生了递归锁， # 定义写法是： lock=threading.RLock() # 使用方法与普通的线程排它锁完全一致。 #信号量：当一个函数的执行是允许有限数量个线程同时去执行的时候适用。 semaphore=threading.BoundedSemaphore(5) #定义一个允许最多5个线程同时执行的信号量。 def my_name(sleep_time): semaphore.acquire() time.sleep(sleep_time) print(threading.current_thread()) semaphore.release() st=random.Random() tl=[] for ii in range(500): ttt = threading.Thread(target=my_name,args=(st.randint(1,3),)) ttt.start() tl.append(ttt) print("当前存活线程数：",threading.active_count()) for rt in tl: rt.join() print("主线程最终结束了")
线程队列，生产者、消费者模型
import queue #导入队列模块 import time,threading,random qq=queue.Queue() #创建队列，除了这种普通队列Queue以外，还有LifoQueue，还有PriorityQueue，有个初始化可选参数，maxsize=0，默认是0不限制，传入数字，就是队列中最多有多少个对象 # 特性不同：队列都是只能取出一次，取出来就没有了。 # 1、Queue：先进先出， # 2、LifoQueue：先进后出， # 3、PriorityQueue：优先级队列，这个队列的使用主要是优先级，数字是越小的数字越优先出，字母是按照ascii码，建议直接向队列中填充的是元组，第一个元素就是优先级数字 def producer(name,p_time): #生产者方法 count=0 print("我是厂家【%s】，我【%s】秒生产一个包子"%(name,p_time)) while True: qq.put("【%s】生产的 包子【%s】"%(name,count)) #向队列里塞入一个对象，我这里塞入的是一个字符串 print("生产厂家【%s】生产了包子【%s】"%(name,count)) count +=1 # time.sleep(p_time) if count>99: break print("仓库有【%s】个包子"%qq.qsize()) qq.join() print("仓库没货了") def consumer(name,c_time): #消费者方法 print("我是吃货【%s】，我【%s】秒吃完一个包子"%(name,c_time)) while True: print("【%s】吃了%s"%(name,qq.get())) #从队列里取出一个对象，因为我知道塞入的是字符串，这里取出来直接打印了 time.sleep(c_time) qq.task_done() rd=random.Random() for i in range(2): #启动两个生产者的线程，调用生产者方法 pt=threading.Thread(target=producer,args=("pt%s"%i,rd.randint(1,3))) pt.start() for i in range(10): #启动10个消费者线程，调用消费者方法 ct=threading.Thread(target=consumer,args=("ct%s"%i,rd.randint(2,4))) ct.start() # qq.get() #从队列中取出一个对象，取不出来就阻塞，直到取出来，可以传参block=False就不阻塞了， # 但是取不到就报异常，参数timeout=None是阻塞超时时间，超时后还取不出来，就报异常 # qq.put() #向队列中塞入一个对象，塞不进去就阻塞，直到能塞进去，可以传入参数block=False就不阻塞了， # 但是塞不进去就报异常，参数timeout=None是阻塞超时时间，超时后还塞不进去，就报异常 # qq.qsize() #返回当前队列中的对象数量 # qq.get_nowait() #不阻塞的取得一个对象，取不出来就异常 # qq.put_nowait() #不阻塞的塞入一个对象，塞不进去就异常 # qq.full() #检查队列是否达到队列设定的最大存放对象的数量，达到返回True，否则返回False # qq.empty() #检查队列是否为空了，为空返回True，否则返回False # qq.task_done() #这个方法是最后队列中的对象被消费后，告诉join()。。。。写程序时task_done()与join()两个方法必须配套出现，不然就会阻塞， # qq.join() #这里如果队列中有对象，则阻塞，没有就不再阻塞
事件驱动！！！（面向事件）：
#写个红绿灯吧，事件触发，红灯亮了，车停了，绿灯亮了，车子开走了 import threading,time # event=threading.Event() #定义一个Event对象，触发器 # # event.wait() #如果设定了标志位，就不阻塞，否则就阻塞 # event.set() #设定标志位 # event.clear() #清除标志位 #这个阻塞等待，可以影响任何线程 #红绿灯例子 event=threading.Event() #定义一个触发器，来控制红灯，绿灯 def light(): #红绿灯闪烁的方法 count=0 #记录秒数 while True: if count<=5:#红灯 print("\033[41;1mred light is on!!!!!\033[0m") #红灯亮了 event.clear() # 红灯，车辆线程要停止运行，所以，触发器将标志位清除 elif count > 5 and count<10: #绿灯 print("\033[42;1mgreen light is on.....\033[0m") #绿灯亮了 event.set() #绿灯，车辆线程要继续运行，往前通过，所以触发器车顶标记位 else: count=0 time.sleep(1) count +=1 def car_run(name): #车辆通行的方法 while True: if event.is_set(): #为了打印出是红等还是绿灯，所以需要判定标记为是否设定，根据红绿灯的逻辑，设定为绿灯，没设定是红灯 print("【%s】看到了绿灯，往前冲！！！"%name) else: print("【%s】红灯了！！！，停车！！！" % name) event.wait() #利用触发器的wait()来根据标记位进行阻塞运行。 time.sleep(0.3) #这个是为了车车们不要跑太快，多不安全呀，呵呵 lttt=threading.Thread(target=light) lttt.start() for i in range(10): #弄出来10个车车线程 car=threading.Thread(target=car_run,args=("car_%s"%int(i),)) car.start()
借楼补充：
断言：断定一个事务 是某些类型，用途是，后续的程序无法回滚，绝对不能出错，可以加断言，因为断言不对，就直接报错了。
#断言 import importlib aa=importlib.import_module("mode3_3.反射") md=aa.Dog("侯杰") assert type(md.name) is str #断言，断定一个事务 是某些类型， md.eat()#断言用途是，后续的程序无法回滚，绝对不能出错，可以加断言，因为断言不对，就直接报错了。
动态引入模块：
#首先是知道模块路径的，这样可以给各种模块附加模块了 #因为这里可以使用字符串，就能用变量，就能随便换了 mm=__import__("mode3_3.反射") #导入的是模块名 导进来的就是模块lib，mm就是导入的模块路径，与写的字符串不一致，上一级路径（也是字符串中明确写的）。 #这是解释器自己用的，官方建议不要用这个 #官方建议用importlib md=mm.反射.Dog("袁伟") #模块路径下的模块下的类 md.eat() import importlib mm=importlib.import_module("mode3_3.反射") #这样是动态的引入了模块名。mm就是模块了，与上边的方法不同点在于最终结果，上边的是路径，这里的是与字符串一致的模块 md = mm.Dog("郭辉") md.eat()
