并发并行同步异步---学习于yuanchengqi老师

并发和并行

并发：系统具有处理多个任务的能力。

并行：系统具有同时处理多个任务的能力。

并行是并发的一个子集。

同步与异步

同步：当进程执行到io操作（等待外部数据）时-----等：同步

异步：不等，去执行其他，一直等到数据接收成功才回来处理。处理效率高。

GIL：全局解释锁

现在你的cpu是4核，有进程1,2,1中有子线程1.1,1.2，2中有2.1.2.2子线程。

进程	线程1	线程2	线程3
进程1	1.1	1.2	1.3（主线程）
进程2	1.1	1.2	1.3（主线程）

那么，1.1,1.2,1.3是什么状态？竞争的状态。GIL加在进程1上，导致1.1,1.2,1.3竞争。

那么，假如，1.1竞争头名，被cpu2执行，那么，1.1暂停执行挂起会因为2个情况：

1.时间轮询 2.io

此时，假如只有1状况导致切换，1.1就会回进程1,1.2或者1.3才能出去。因为只有一个线程才能执行。

所以，因为gil，同一时刻，只有一个线程被cpu执行。导致了会来回切换。

为什么加锁呢？解释器的问题。

导致的后果：不能做到能充分利用每个cpu，只能用一个cpu。

那，肿么办呢？把不同的线程分到不同的进程中去。或者，多进程+协程。

####

程序做的事有IO密集型和计算密集型。

对于IO密集型：python的多线程有意义，可以采用多进程+协程；
对于计算密集型：python的多线程不推荐。

同步锁

import time
import threading

def addNum():
    global num #在每个线程中都获取这个全局变量
    #num-=1

    temp=num
    #print('--get num:',num )
    time.sleep(0.1)
    num =temp-1 #对此公共变量进行-1操作

num = 100  #设定一个共享变量
thread_list = []
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕
    t.join()

print('final num:', num )

R=threading.Lock()
 
####把sub变成串行，但是其他的函数不是串行
def sub():
    global num
    R.acquire()
    temp=num-1
    time.sleep(0.1)
    num=temp
    R.release()

同步对象event

比如打开个网页就是同步的。你这边只有请求之后，那边接受返回之后，才会显示，那么，这个步骤有等。

注册账号，如果没注册完，然后点一下其他地方，会直接发送没注册完的信息给服务器，这里是异步。

event 同步对象：
设置event，让2个线程同步起来。

event = threading.Event() #创建
event.wait()  #如果event set 是False，那么block在这个过程
event.set()   #set event状态
event.clear()  #清除event状态

import threading,time  #思路跟着顺序来。
class Boss(threading.Thread):
    def run(self):
        print("BOSS：今晚大家都要加班到22:00。")
        print(event.isSet())   #event此时还是FALSE
        event.set() #4 设定event，event此时是TRUE，睡觉了5秒，那么在这五秒中内
        time.sleep(5)
        print("BOSS：<22:00>可以下班了。")
        print(event.isSet())
        event.set()   #8 重新set event 为 TRUE
class Worker(threading.Thread):
    def run(self):
        event.wait()   #3，因为有wait，这时候还没有eventset，所以block；所有worker都block了。没显示。这时候，cpu，执行BOSS
        print("Worker：哎……命苦啊！")  #5，因为event为TRUE，所以每个工人开始抱怨了。
        time.sleep(1) #6
        event.clear() #6 抱怨完后开始干活，清空愤怒槽
        event.wait()  #7，一秒钟就做完了，因为清空了愤怒槽event，变成FALSE，又挂起来了。5个工人都轮完后，BOSS开始
        print("Worker：OhYeah!")  #9 开心

if __name__=="__main__":
    event=threading.Event()    #1，创建一个event
    threads=[]  #一个list，进行相同操作,list中其实可以添加任意元素，就是对象，因为是obj，而每个类都是obj，实例也是ob
    for i in range(5):   #启动了5个线程
        threads.append(Worker())  #thread-1,thread-2,thread-3,thread-4,thread-5添加进去
    threads.append(Boss())  #bossthread添加
    for t in threads： #2，线程开始运行
        t.start()
    for t in threads：#线程加入，在这些子线程还没结束前，父线程都是阻塞状态
        t.join() 

信号量

用来控制线程并发数的。同步锁是指定只有一个线程可以运行，信号量是指定同时有多个线程进行。

import threading,time
class myThread(threading.Thread):
    def run(self):
        if semaphore.acquire():  #设定这个thread受信号量调控
            print(self.name)
            time.sleep(5)  #停了54秒之后才释放5个线程
            semaphore.release()
if __name__=="__main__":
    semaphore=threading.Semaphore(5)  #设定同时可以开5个
    thrs=[]
    for i in range(100):
        thrs.append(myThread())
    for t in thrs:
        t.start()