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()