1。今天讲了一下线程安全的问题   线程安全的有,列表,字典,队列(队列在后面生产者消费者模型里有)

2.锁,最普通的锁    lock

import threading
import time

v = []
lock = threading.Lock()

def func(arg):
    lock.acquire()        #这个只能锁一次,如果锁两次及以上就会锁死
    v.append(arg)
    time.sleep(0.01)
    m = v[-1]
    print(arg,m)
    lock.release()     #这个正常解锁一次就OK了,上边锁多了,下面怎么也解不开


for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

 3,锁,用的最多的锁 Rlock

import threading
import time

v = []
lock = threading.RLock()
def func(arg):
    lock.acquire()   #这个可以锁2次       及以上
    lock.acquire()

    v.append(arg)
    time.sleep(0.01)
    m = v[-1]
    print(arg,m)

    lock.release()#上面锁几次这就解几次
    lock.release()


for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()                

 4,锁,名字最长的锁

import time
import threading

lock = threading.BoundedSemaphore(3)  #你这里写多少,他就一次走几个线程
def func(arg):
    lock.acquire()
    print(arg)
    time.sleep(1)
    lock.release()


for i in range(20):
    t =threading.Thread(target=func,args=(i,))
    t.start()

 5.锁,

import time
import threading

lock = threading.Condition()

# ############## 方式一 ##############

def func(arg):
    print('线程进来了')
    lock.acquire()   #这个锁还是必加的
    lock.wait() # 加锁     这里新加的锁,在多写一个主线程

    print(arg)
    time.sleep(1)

    lock.release()  #同上


for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

while True:
    inp = int(input('>>>'))    #一次输入多少就执行多少线程

    lock.acquire()   #同上
    lock.notify(inp)  #固定写法
    lock.release()   #同上


# ############## 方式二 ##############
"""
def xxxx():
    print('来执行函数了')
    input(">>>")     #这个智能一点,在这里可以等到执行一个with open  等。。。然后才返回值,返回什么还可以再随机
    # ct = threading.current_thread() # 获取当前线程
    # ct.getName()
    return True

def func(arg):
    print('线程进来了')
    lock.wait_for(xxxx)    #一直在等,等某个条件满足了,就往下走
    print(arg)
    time.sleep(1)

for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

6,锁,

import time
import threading

lock = threading.Event()


def func(arg):
    print('线程来了')
    lock.wait() # 加锁:红灯
    print(arg)


for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

input(">>>>")
lock.set() # 绿灯      只要没有绿灯就一直锁死,只要绿灯过一次
lock.wait()  #只要绿灯过一次,这里再写几个也没用,只有clear有用

lock.clear() # 再次变红灯

for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

input(">>>>")
lock.set()

 7.  threading.local()

import time
import threading

v = threading.local()

def func(arg):
    # 内部会为当前线程创建一个空间用于存储:phone=自己的值
     会为每一个线程储存一个空间
    v.phone = arg
    time.sleep(2)
    print(v.phone,arg) # 去当前线程自己空间取值    这两个值一样

for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()    

8.threadinglocal原理 

import time
import threading

DATA_DICT = {}

def func(arg):
    ident = threading.get_ident() 获取当前线程ID #c= threading.current_thread()  获取当前线程对象
    DATA_DICT[ident] = arg
    time.sleep(1)
    print(DATA_DICT[ident],arg)


for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()

 9.threadinglocal为每个线程维护一个空间(字典),用于当前线程存取自己的值,保证线程之间的数据隔离 {线程id:{自己的key:自己的value}}

import time
import threading
INFO = {}
class Local(object):

    def __getattr__(self, item):
        ident = threading.get_ident()
        return INFO[ident][item]

    def __setattr__(self, key, value):
        ident = threading.get_ident()
        if ident in INFO:
            INFO[ident][key] = value
        else:
            INFO[ident] = {key:value}

obj = Local()

def func(arg):
    obj.phone = arg # 调用对象的 __setattr__方法(“phone”,1)
    time.sleep(2)
    print(obj.phone,arg)


for i in range(10):
    t =threading.Thread(target=func,args=(i,))
    t.start()



每个对象都是调用上面的方法
def __getitem__(self,item)
obj['x']
def __getattr__(self,item)
obj.x  执行了他就等于执行attr x=item
def __setattr__(self,key,value):
obj.x=6    这个key是x value是6

 10.小数据池

from concurrent.futures import ThreadPoolExecutor
import time

def task(a1,a2):
    time.sleep(2)
    print(a1,a2)

# 创建了一个线程池(最多5个线程)
pool = ThreadPoolExecutor(5)

for i in range(40):
    # 去线程池中申请一个线程,让线程执行task函数。
    pool.submit(task,i,8)         




for i in range(10):    同比这个来讲的话     下面的对象这个要等于一下,arsg传值,上面的 一个submit就全搞定了
    t =threading.Thread(target=func,args=(i,))
    t.start()

 11.生产者消费者模型

用户是生产者,程序是消费者        生产者把东西放在这里,客户端接收到了就去工作

解决了一直等待的问题,让客服端和服务端不用直接交互,放在队列里互相等待