锁：
经典面试题
# # GIL # # 锁 import time from threading import Thread,Lock def func(lock): global n # lock.acquire() temp = n #在这里睡了一秒，所以程序会进入就绪状态，下面又是同步运行，但是上面可以异步运行（global n 和 temp = n） # time 会让程序重新进入就绪状态，每一次执行子线程，都会改变global n,而不是真正的n time.sleep(0.1) n = temp -1 # lock.release() n = 100 t_lst = [] lock = Lock() # 锁 for i in range(100): t = Thread(target=func,args=(lock,)) t.start() t_lst.append(t) for t in t_lst:t.join() #让所有线程变成同步的 print(n) # 数据是不隔离 # from threading import Thread # # def func(): # global n # temple = n # n = temple - 1 # # n = 100 # for i in range(100): # t = Thread(target = func) # t.start() # print(n)
互斥锁：
from threading import Thread,Lock
lock = Lock()
lock.acquire()
lock.acquire()
lock.acquire()
lock.release()
# 卡住了（阻塞了）
科学家吃面问题：
# from threading import Lock
#
# lock= Lock() # 在同一个线程中
# # 能够被一个锁的多个acquire阻塞住了
# # 这种锁就叫做互斥锁
# lock.acquire()
# lock.acquire()
# 科学家吃面问题
# 要完成一件事情 需要两个必要因素
# 要想吃到面 叉子 面
# 资源的互相抢占的问题 —— 死锁
# import time
# from threading import Thread,Lock
# def eat1(noodle_lock,fork_lock,name):
# noodle_lock.acquire()
# print('%s抢到了面'%name)
# fork_lock.acquire()
# print('%s抢到了叉子'%name)
# print('%s正在吃面'%name)
# fork_lock.release()
# print('%s归还了叉子' % name)
# noodle_lock.release()
# print('%s归还了面' % name)
#
# def eat2(noodle_lock,fork_lock,name):
# fork_lock.acquire()
# print('%s抢到了叉子' % name)
# time.sleep(0.5)
# noodle_lock.acquire()
# print('%s抢到了面'%name)
# print('%s正在吃面'%name)
# noodle_lock.release()
# print('%s归还了面' % name)
# fork_lock.release()
# print('%s归还了叉子' % name)
#
# if __name__ == '__main__':
# noodle_lock = Lock()
# fork_lock = Lock()
# Thread(target=eat1,args=(noodle_lock,fork_lock,'yuan')).start()
# Thread(target=eat2,args=(noodle_lock,fork_lock,'egon')).start()
# Thread(target=eat1,args=(noodle_lock,fork_lock,'nezha')).start()
# Thread(target=eat2,args=(noodle_lock,fork_lock,'alex')).start()
# 递归锁
# from threading import Thread,RLock
# # 在同一个线程中对同一个锁多次acquire不会产生阻塞
# # 递归锁
# def func(rlock,flag):
# rlock.acquire()
# print(flag*10)
# rlock.acquire()
# print(flag * 10)
# rlock.acquire()
# print(flag * 10)
# rlock.acquire()
# print(flag * 10)
# rlock.release()
# rlock.release()
# rlock.release()
# rlock.release()
# rlock = RLock()
# Thread(target=func,args=(rlock,'*')).start()
# Thread(target=func,args=(rlock,'-')).start()
import time
from threading import Thread,RLock
def eat1(noodle_lock,fork_lock,name):
noodle_lock.acquire()
print('%s抢到了面'%name)
fork_lock.acquire()
print('%s抢到了叉子'%name)
print('%s正在吃面'%name)
fork_lock.release()
print('%s归还了叉子' % name)
noodle_lock.release()
print('%s归还了面' % name)
def eat2(noodle_lock,fork_lock,name):
fork_lock.acquire()
print('%s抢到了叉子' % name)
time.sleep(0.5)
noodle_lock.acquire()
print('%s抢到了面'%name)
print('%s正在吃面'%name)
noodle_lock.release()
print('%s归还了面' % name)
fork_lock.release()
print('%s归还了叉子' % name)
if __name__ == '__main__':
fork_lock = noodle_lock = RLock()
Thread(target=eat1,args=(noodle_lock,fork_lock,'yuan')).start()
Thread(target=eat2,args=(noodle_lock,fork_lock,'egon')).start()
Thread(target=eat1,args=(noodle_lock,fork_lock,'nezha')).start()
Thread(target=eat2,args=(noodle_lock,fork_lock,'alex')).start()
# 有超过一个资源需要锁的时候 —— 递归锁
# 递归锁的应用场景
# 互斥锁和递归锁的区别
import time
import random
from threading import Event,Thread
# wait()
# set clear isset
# 连接数据库
def connect_db(e):
count = 1
while count < 4: #第一次进入默认是False
print('尝试第%s次检测连接'%count)
e.wait(0.5)
# 如果不传参数会一直等到事件为True为止
# 如果传参数 传一个时间参数
count += 1
if e.is_set():
print('连接成功')
break
else:
print('连接失败')
def check_conn(e):
'''检测数据库是否可以连接'''
time.sleep(random.randint(1,2))
e.set() 此题：如果小于1.5 会把状态False 改为 True ,否则会执行else:结束程序
e = Event()
Thread(target=check_conn,args=(e,)).start()
Thread(target=connect_db,args=(e,)).start()
# 你要做一件事情 是有前提的
# 你就先去处理前提的问题 —— 前提处理好了 把状态设置成True
# 来控制即将要做的事情可以开始
条件和定时器：
from threading import Condition,Thread
# # acquire release
# # notify -- wait的行为
# # 10线程 wait
# # notify(1)
# def func(i,con):
# con.acquire()
# con.wait()
# print(i*'*')
# con.release()
#
# con = Condition()
# for i in range(10):
# Thread(target=func,args=(i,con)).start()
# while True:
# n = int(input('>>>'))
# con.acquire()
# con.notify()
# con.release()
#
# con.acquire()
# con.notify_all()
# con.release()
# semaphore 允许统一是个n个线程执行这段代码
# event 有一个内部的事件来控制wait的行为
#控制的是所有的线程
# condition 有一个内部的条件来控制wait的行为
#可以逐个或者分批次的控制线程的走向
from threading import Timer
def func():
print('*'*20)
t = Timer(5,func) # 要开启一个线程，等到5秒钟之后才开启并且执行
t.start()
print('-'*10)
print('^'*10)
队列：
import queue
q = queue.LifoQueue()
q = queue.Queue()
q.put('first')
q.put((1,2))
q.put([1,2])
q.put({'k':'v'})
q.put(lambda :1)
print(q.get())
print(q.get())
print(q.get())
print(q.get())
q = queue.PriorityQueue()
q.put((1,'a')) #数字越小优先级越高
q.put((20,'z'))
q.put((20,'b'))
print(q.get())
print(q.get())
print(q.get())
线程池：
# import time
# from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
# def func(i):
# print(i*'*')
# time.sleep(1)
# return i**2
#
# def callb(arg):
# print(arg.result()*'-')
#
# if __name__ == '__main__':
# # thread_pool = ThreadPoolExecutor(5)
# thread_pool = ThreadPoolExecutor(5)
# # ret_lst = []
# for i in range(10):
# thread_pool.submit(func,i).add_done_callback(callb) # 相当于apply_async
# # ret = thread_pool.submit(func,i).add_done_callback(callable) # 相当于apply_async
# # ret_lst.append(ret)
# thread_pool.shutdown() # close+join
# # for ret in ret_lst:
# # print(ret.result())
# print('wahaha')
# # 回调函数
# 进程池
# 线程池
# 当内存不需要共享，且高计算的时候 用进程
# 当内存需要共享，且高IO的时候 用线程
# 当并发很大的时候
# 多进程 ： 多个任务 —— 进程池 ：cpu个数、cpu个数+1
# 多线程 ：多个任务 —— 线程池 ：cpu个数*5
# 4C : 4个、5个进程 —— 20条线程/进程 ： 80-100个任务
# 50000
# import time
# from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
#
# def fun(i):
# print(i*'*')
# time.sleep(1)
# return i**2
#
# def callc(args):
# print(args.result()*'-')
#
#
# thread_pool = ThreadPoolExecutor(5)
# for i in range(10):
# ret = thread_pool.submit(fun,i).add_done_callback(callc)
# # thread_pool.map(fun,range(10))
# thread_pool.shutdown()
# print('wahh')
import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def fun(i):
print('*'*i)
time.sleep(1)
return i**2
def callc(args):
print(args.result() * '-')
thread_pool = ThreadPoolExecutor(5)
for i in range(10):
ret = thread_pool.submit(fun,i).add_done_callback(callc)
thread_pool.shutdown()
print('主线程')