#同步 异步的概念
#同步:同步就是协同步调,按预定的先后次序进行运行,如:你先说,我再说,“同”是指协同,协助,互相配合
#如进程、线程同步,可以理解为进程或线程A和B一块配合,A执行到一定程度时要依靠B的某些结果,于是停下来,示意B运行,B依言而行,再将结果给A,A再继续操作
同步调用类似 你 喊 你朋友吃饭,你朋友在忙,你就在那里一直等,等你朋友忙完了你们一起去
#异步:异步调用就是 你 喊 你朋友吃饭,你朋友说知道了,待会忙完去找你,你就去做别的了
from multiprocessing import Pool
import time
import os
def download():
print("进程池中的进程————pad=%d,ppid=%d--"%(os.getpid(),os.getppid()))
for i in range(3):
print("---%d---"%i)
time.sleep(1)
return "下载完成!"
def alterUser(args):
print("---callback func--pid=%d"%os.getpid())
print("---callback func--args=%s"%args)
if __name__ == '__main__':
pool=Pool(3)
pool.apply_async(func=download,callback=alterUser)
print("-----start-----")
pool.close()
pool.join()
print("-----end-----")
#互斥锁
#当多个线程几乎同时修改一个共享数据的时候,需要进行同步控制,线程同步能够保证多个线程安全的访问竞争资源(全局内容),最简单的同步机制就是使用互斥锁,某个线程要更改共享数据时,先将其锁定,此时资源的状态为锁定状态,其他线程就不能更改,直到该线程将资源状态改为非锁定状态,也就是释放资源,其他线程才能再次锁定资源,互斥锁保证了每一次只有一个线程进入写入操作,从而保证了多线程下数据的安全性
from threading import Thread,Lock
import time
g_num=0
def xian1():
global g_num
for i in range(10):
lock.acquire(blocking=True)
# time.sleep(0.1)
print("1上锁")
g_num+=1
lock.release()
print("1释放")
print("1-----",g_num,"#")
def xian2():
global g_num
for i in range(50):
lock.acquire(blocking=True)
time.sleep(0.2)
print("2上锁")
g_num += 1
lock.release()
print("2释放")
print("2-----", g_num, "#")
if __name__ == '__main__':
lock=Lock()
t1=Thread(target=xian1)
t2=Thread(target=xian2)
t1.start()
t1.join()
t2.start()
t2.join()
#总结:
#锁的好处:确保了某段关键代码只能由一个线程从头到尾完整执行
#锁的坏处: 1、阻止了多线程的并发执行,包含锁的某段代码实际上只能以单线程模式执行,效率就大大下降了
#2、由于可以存在多个锁,不同的线程持有不同的锁,并试图获取对方持有的锁时,可能会造成死锁
#死锁 :在多个线程共享资源的时候,如果两个线程分别占有一部分资源,并且同时等待对方额资源,就会造成死锁现象,如果锁之间相互嵌套,就有可能出现死锁。因此尽量不要出现锁之间的嵌套
import time
from threading import Thread,Lock
def func1():
lockA.acquire()
print("我得到A锁")
time.sleep(1)
lockB.acquire()
print("我得到B锁")
lockA.release()
lockB.release()
def func2():
lockB.acquire()
print("func2B锁")
time.sleep(1)
lockA.acquire()
print("func2A锁")
lockB.release()
lockA.release()
if __name__ == '__main__':
lockA=Lock()
lockB=Lock()
t1=Thread(target=func1)
t2=Thread(target=func2)
t1.start()
t2.start()
#生产者和消费者模式
import time
from queue import Queue
from threading import Thread
q= Queue(10)
def produce(name):
count=1
while True:
q.put("%s包子%d"%(name,count))
print("%s生产了包子%d"%(name,count))
count+=1
time.sleep(1)
def consumer(name):
while True:
print("{}消费{}".format(name,q.get()))
time.sleep(1)
if __name__ == '__main__':
t1=Thread(target=produce,args=("张三",))
t1.start()
t2=Thread(target=consumer,args=("李四",))
t2.start()
p1=Thread(target=produce,args=("王五",))
p1.start()
p2=Thread(target=produce,args=("赵柳",))
p2.start()
threadLocal
import time
import threading
from threading import Thread
loc_s = threading.local()
def process():
std = loc_s.name
num = loc_s.num
print("hello%s,学号%s,线程%s" % (std, num, threading.current_thread()))
def process_thread(name, num):
loc_s.name = name
loc_s.num = num
time.sleep(1)
process()
if __name__ == '__main__':
t1 = Thread(target=process_thread, args=("张三", "001"), name="线程1")
t2 = Thread(target=process_thread, args=("李四", "002"), name="线程2")
t1.start()
t2.start()
#全局解释器锁
import time
from threading import Thread
def jisuan():
start=time.time()
he=0
for i in range(10000000):
he+=1
end=time.time()
print(end-start)
if __name__ == '__main__':
t1=Thread(target=jisuan)
t1.start()
t1=Thread(target=jisuan)
t1.start()
#协程
def A():
for i in range(2):
print("A-----")
yield i
def B(a):
for i in range(2):
print("B-----")
next(a)
if __name__ == '__main__':
a=A()
B(a)
#拓展
import gevent,time
def f1():
for i in range(3):
print("this is f1",i)
gevent.sleep(1)
def f2():
for i in range(3):
print("this is f2",i)
gevent.sleep(1)
if __name__ == '__main__':
t1=gevent.spawn(f1)
t2=gevent.spawn(f2)
gevent.joinall([t1,t2])