python 多线程的函数传参和取返回,加锁，守护线程，线程池，多进程

import threading,time,random
a=[]
def exce(db):#函数有参数
    print(threading.current_thread())#看当前哪一个进程在运行
    time.sleep(random.randint(1,5))
    print('洗衣服')
    return a.append(random.randint(1,5))#如何拿到返回值
for i in range(10):#你要起多少线程就写多少
    t=threading.Thread(target=exce,args=['db1'])#想要传函数的参数使用args方法
    #多个参数用args=['db1','ces']
    t.start()
while threading.active_count()!=1:
    pass
#如果想拿到返回值该怎么搞呢，

数据大应该分给不同的线程 

讲一讲线程锁 
线程和线程之间数据事共享的，工厂的厕所 
 
大数据时间显示的不对，为什么呢，因为大家同同时操作数据会错乱，这个时候就要用锁，先把这个数据锁上

import threading

count = 0
lock=threading.Lock()#实例化一把锁
#多个线程操作同一个数据就要加锁就不会出错，线程安全 
def add():
    global count
    for i in range(10000):
        lock.acquire()#加锁
        count+=1
        lock.release()#解锁

for i in range(2):
    t = threading.Thread(target=add)
    t.start()


while threading.active_count()!=1:
    pass

print(count)

# with lock:
# count += 1 第二种写法  

如果只加锁不解锁的话   就会死锁  没有反应

守护线程 

存在一个陪葬的作用，守护主线程，一但主线程死掉，守护线程立马死掉 

import threading
import time
import random
def talk(name):
    print('正在和%s聊天'%name)
    time.sleep(random.randint(1,5))
    print('和%s聊完了'%name)

t = threading.Thread(target=talk,args=['尹路明']) #起了四个线程
t.setDaemon(True) #设成守护线程
t.start()


t = threading.Thread(target=talk,args=['刘海洋'])
t.setDaemon(True) #设成守护线程
t.start()

t = threading.Thread(target=talk,args=['方丹'])
t.setDaemon(True) #设成守护线程
t.start()

t = threading.Thread(target=talk,args=['代爽'])
t.setDaemon(True) #设成守护线程
t.start()
# while threading.active_count()!=1: #主线程等子线程
#     pass

print('退出qq')

队列的介绍，队列 大家一定听过消息队列，队列就和一个List差不多，比如list等于1.2.3.4
队列和list的区别，队列先加进来1处理完1，1就不在里面了
谁先进来我先处理谁
什么时候用到队列，双十一用到队列，来到请求接收到，放到队列里，再用一个东西去队列里取东西在慢慢处理
异步函数就是队列的称呼
队列干嘛的，其实就是跟排队一样的
python 里面如何使用队列
import threading,queue,random,time
orders_q = queue.Queue()

#生产者/消费者模式

def producer():#生产数据
    for i in range(100):
        order_id = random.randint(1, 99999)
        print('订单生成，orderid:%s'%order_id)
        orders_q.put(order_id)#put加数据
        time.sleep(1)

def consumer(): #消费者
    while True:#死循环
        if orders_q.qsize()>0:#如果有数据
            oreder_id = orders_q.get()#获取生成的订单
            print('consumer1,订单落库',oreder_id)
t = threading.Thread(target=producer)
t.start()

t = threading.Thread(target=consumer)
t.start()
#这就是异步处理逻辑，数据来了就消费
跑自动化时候特别多的情况下，三台机子运行，每台机子起多少个线程，怎么保证用例都被运行 ，我生成者运行那台机器，我发送三台机器
我每一台机器都去三台机器取线程 运行完了就结束，这就是分布式的运行