同步异步、阻塞非阻塞、进程

1.同步与异步

1.同步异步用来表达任务的提交方式

2.同步:同步是指一个进程在执行某个请求的时候，如果该请求需要一段时间才能返回信息，那么这个进程会一直等待下去，直到收到返回信息才继续执行下去。
'''所谓同步就是一个任务的完成需要依赖另外一个任务时,只有等待被依赖的任务完成后,依赖的任务才能算完成。要么都成功,要么都失败,两个任务的状态保持一致。代码层面来说:代码执行到某行时,如果代码需要调用其他代码,那么就去其他文件执行代码,执行完之后再回来,如果被依赖的代码执行错误,那么依赖的代码同样错误。'''
    
3.异步:异步是指进程不需要一直等待下去，而是继续执行下面的操作，不管其他进程的状态，当有结果返回的时候会通知进程进行处理，这样就可以提高执行的效率了，即异步是我们发出的一个请求，该请求会在后台自动发出并获取数据，然后对数据进行处理，出现结果时消息通知原进程,在此过程中，我们可以继续做其他操作，不管它怎么发出请求，不关心它怎么处理数据。

'''代码执行到某行时,如果代码需要调用其他代码,继续往下执行'''
"""
你和朋友去吃饭，你们到达饭店，点了一桌满汉全席。由于你们饿的不行，就在饭店等待厨师做好菜，等菜上桌。你和你的朋友吃完饭，付了钱，舒舒服服的去商场购物了，一次饭局就结束了。这就是同步调用。

如今，我们正处在互联网时代，当你们饿的时候，就打开饿了么，点了一桌满汉全席，支付了餐费，这时你就完成了点菜。商家接到了你的订单之后，就会马上开始安排（毕竟顾客就是上帝嘛）。现在你们无须默默等待，以免被饿所折磨，于是你们打开了京东，开始了新的购物。当饿了么小哥饭菜送到时，一签单就完事了，并且你们也完成了购物。这就是异步调用。
我们之前所写的代码都是同步调用。
"""

2.阻塞与非阻塞

阻塞与非阻塞表达任务的执行状态

1.阻塞:任务处于阻塞态
    
2.非阻塞:任务处于就绪态、运行态

3.综合使用

我们通常不会只看到上述单个词汇,而是会看到上述词汇的组合使用,含义举例说明:
1.同步阻塞:只运行这一个程序,提交任务之后,等待CPU回来继续运行,效率最低。
'''去银行排队,专心排队其他什么事情都不做'''
  
2.同步非阻塞:只运行这一个程序,提交完任务之后,可以原地做一些其他的事情。
'''还是用普通的汤锅，米放进去，然后去打游戏，过一会就来看一次 '''

3.异步阻塞:程序处于阻塞态,但是可以做一些其他操作。
'''去某宝淘了个电饭锅，饭熟了会自动跳闸的那种。米放进去，然后傻傻的看它怎么做饭的'''

4.异步非阻塞:提交完任务之后CPU马上去运行另一个程序,并且处于运行态或者就绪态,异步非阻塞效率最高。
'''米放进去，按下按钮，然后就去打游戏了，等到跳闸的时候就去吃饭。'''

"""
同步异步一般是针对于客户端请求的连接来说的。客户端请求服务端处理一个数据,同步的状态下客户端会一直等待该数据的处理结果。异步操作下服务端连接后直接返回,告诉服务端处理完成之后给我一个信息就好。

阻塞和非阻塞是根据服务端请求线程来说的。阻塞的情况下请求线程不能去做其他事情,一直处于等待的状态。非阻塞请求发出之后请求的线程不用一直等待,可以去处理其他的请求,但是请求线程会每隔一段时间看一下处理线程，处理结果有没有完成。

综合举例解释:顾客去餐厅吃饭,餐厅既有服务员也有厨师,可以将服务员看做是请求线程,厨师看做是处理线程。同步阻塞:顾客点了菜,服务员把菜单传给厨师,做的过程中,顾客不做任何事情等待上菜,服务员也等待传菜不作任何事情。同步非阻塞:点完菜之后顾客依然处于等待上菜而不做任何事的状态,但是服务员把菜单传给厨师之后服务员可以去服务其他顾客,并且服务员每隔一段时间服务员会问厨师菜是否已经做好。异步阻塞:估计点完菜说,我想出去溜达一下,什么时候菜好了给我打个电话。但是服务员把菜单给厨师之后自己等菜品做好然后给顾客上菜。异步非阻塞:顾客点完菜点完菜可以去做其他的事情,服务员把菜单给厨师之后也可以去服务其他桌。服务员把菜单放在桌子上,厨师挨个从桌子上拿菜单并且做菜,桌子可以看做是消息队列。
"""

4.创建进程的多种方式

1.两种方式:
	1.1 鼠标双击软件图标
	1.2 python代码
    
2.用python代码创建进程(方法一):
"""
不同的操作系统盘创建进程的底层原理不一样
windows:以导入模块的形式创建进程
linux:以拷贝代码的形式创建进程
"""
windows如果用代码创建进程,进程文件相当于导模块,会将原来的代码原封不动地拷贝一份到新进程,新进程执行到创建进程那一步会继续创建新进程,往复循环,直到报错。而苹果电脑创建的新进程会不包含创建新进程的那一步,所以苹果电脑创建新进程不会循环报错。windows代码及报错信息如下:
from multiprocessing import Process
import time

def task(name):
    print('task is running', name)
    time.sleep(3)
    print('task is over', name)

p1 = Process(target=task)
p1.start()
print('主进程')

"""
windows创建新进程是以导模块的形式创建,所以导模块的几步应该要加上验证是否是执行文件的:if __name__ == '__main__'。
"""
from multiprocessing import Process
import time

def task(name):
    print('task is running', name)
    time.sleep(3)
    print('task is over', name)

if __name__ == '__main__':
    p1 = Process(target=task,args=(111,))  # 创建一个子进程对象
    p1.start()  # 用子进程对象创建一个新的进程,并在该进程中执行task功能
    print('主进程')  # 执行结果:主进程 task is running 111 task is over 111
说明p1.start()生成一个新进程是一个异步操作,子进程中调用task函数,因为子进程拷贝代码需要时间,所以父进程中的print('主进程')会优先打印,打印结束之后会再执行子进程。

from multiprocessing import Process
import time

def task(name):
    print('task is running', name)
    time.sleep(3)
    print('task is over', name)

def func1():
    print('from func1')

if __name__ == '__main__':
    p1 = Process(target=task,args=(111,))
    p2 = Process(target=func1)
    p1.start()
    p2.start()
    print('主进程')
# 执行结果:主进程 task is running 111 from func1 task is over 111
一个父进程可以同时开多个子进程,子进程P1在读取的过程中先执行print('主进程'),再执行子进程p1中的print('task is running', name),此时子进程p1中还有部分代码未执行,由于要sleep3秒,此时先执行p2中的print('from func1'),最后执行print('task is over', name)。

3.用python代码创建进程(方法二):
from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self, name, age):
        super().__init__()
        self.name = name
        self.age = age

    def run(self):
        print('run is running', self.name, self.age)
        time.sleep(3)
        print('run is over', self.name, self.age)

if __name__ == '__main__':
    obj = MyProcess('max', 25)
    obj.start()
    print('主进程') 
#  主进程  run is running max 25  run is over max 25
该方法是利用类产生对象,然后用对象产生子进程的过程。还是先执行父进程中的print('主进程'),再执行子进程中的run is running max 25、run is over max 25。

5.进程的join方法、数据隔离

'''同一台计算机上的多个进程数据是严格意义上的物理隔离(默认情况下)'''
money = 1000

def task():
    money = 666

if __name__ == '__main__':
    task()
    print(money)
#  1000 print(money)找的是全局名称空间中的money

money = 1000

def task():
    global money
    money = 666

if __name__ == '__main__':
    task()
    print(money)
#  666 global局部修改全局,主进程全局名称空间中的money被改成666

from multiprocessing import Process
import time

money = 1000

def task():
    global money
    money = 666
    print('子进程中的money', money)  #  子进程中的money 666  

if __name__ == '__main__':
    p1 = Process(target=task)
    p1.start()
    time.sleep(3)
    print(money)
# 1000
"""
如果没有if __name__ == '__main__':及子代码,此时全局名称空间中的money已经被修改成666,局部名称空间中无money。但是要生成一个子进程,在子进程中调用task()函数,子进程中会调用全局名称空间中的money以及task()函数,task()函数执行修改的是子进程中全局名称空间中的money。task()函数体代码中查看的是子进程中的money,结果是666,说明已经修改。
"""

需求:如何实现子进程运行结束之后再运行主进程?
from multiprocessing import Process
import time
    
def task(name):
    print('%s is running' % name)
    time.sleep(3)
    print('%s is over' % name)

if __name__ == '__main__':
    p = Process(target=task, args=('max',))
    p.start()
    print('主进程')
# 主进程  max is running  max is over
"""
正常运行会先执行父进程的所有代码(父进程中有IO操作的除外),再执行子代码,因为在子代码读取过程中CPU会先读取父代码并且执行
"""
from multiprocessing import Process
import time

def task(name):
    print('%s is running' % name)
    time.sleep(3)
    print('%s is over' % name)

if __name__ == '__main__':
    p = Process(target=task, args=('max',))
    p.start()
    time.sleep(4)
    print('主进程')
#  max is running  max is over 主进程 
"""
上述代码实现了先执行子进程再执行父进程,依靠的是父进程休眠时间总是比子进程长一些。但这种方法的弊端在于我们不知道子进程什么时候会休眠几秒,使用这种方式存在很多不确定性
"""
from multiprocessing import Process
import time

def task(name):
    print('%s is running' % name)
    time.sleep(3)
    print('%s is over' % name)

if __name__ == '__main__':
    p = Process(target=task, args=('max',))
    p.start()
    p.join()
    print('主进程')
#  max is running  max is over 主进程
"""
join()方法不管子进程需要休眠多少秒,直到执行完行子进程,再执行父进程
"""
from multiprocessing import Process
import time

def task(name, n):
    print('%s is running' % name)
    time.sleep(n)
    print('%s is over' % name)

if __name__ == '__main__':
    p1 = Process(target=task, args=('max1',1))
    p2 = Process(target=task, args=('max2',2))
    p3 = Process(target=task, args=('max3', 3))
    start_time = time.time()
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    print(time.time() - start_time)
"""
max1 is running
max2 is running
max3 is running
max1 is over
max2 is over
max3 is over
3.151333808898926
"""
"""
根据前六部打印顺序得知,第一个子进程先开始,不等睡眠结束就开始运行第二个,再第三个。start()连在一起说明无需等待上一个子进程结束就可以开始下一个。
"""
from multiprocessing import Process
import time

def task(name, n):
    print('%s is running' % name)
    time.sleep(n)
    print('%s is over' % name)

if __name__ == '__main__':
    p1 = Process(target=task, args=('max1',1))
    p2 = Process(target=task, args=('max2',2))
    p3 = Process(target=task, args=('max3', 3))
    start_time = time.time()
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
    print(time.time() - start_time)
"""
max1 is running
max1 is over
max2 is running
max2 is over
max3 is running
max3 is over
6.363624334335327
"""
"""
join()表示必须等子进程运行结束之后才能运行主进程,同时也表示上一个子进程结束之后才能运行下一个。
"""

6.IPC机制

IPC机制:同一台电脑上进程间通信
消息队列:存储数据的地方,所有人都可以存,也可以取,类似于一个仓库
"""
知识回顾:队列:先进先出;栈:先进后出
"""
from multiprocessing import Queue

q = Queue(3)
q.put(11)
print(q.full())  # False 判断队列是否已满
q.put(22)
q.put(33)
print(q.full())  # True
# q.put(44)  # 数量超过存放数量,不会报错,但是不会再执行下面的代码了,想要继续执行要把这一行注掉
print(q.get())  # 11
print(q.get())  # 22
print(q.empty())  # False 判断列表是否为空
print(q.get())
print(q.get_nowait())  # 拿完了,用get_nowait()继续拿会直接报错
"""
full(), empty()在多进程中不能使用,因为判断的上一刻列表数据可能就发生变化。聊天软件中的消息即使不上线也可以收到,因为消息存放在消息队列中。
"""

7.进程中通信

上述知识点我们得知了队列可以当做一个仓库来存放数据,那么队列是否可以当做不同进程之间数据联系的仓库呢?
from multiprocessing import Process, Queue

def consumer(q):
    '''在子进程中拿出数据'''
    print('子进程从队列当中拿到的数据:', q.get())

if __name__ == '__main__':
    q = Queue()
    '''在主进程中添加数据'''
    q.put('主进程添加的数据a')
    p1 = Process(target=consumer, args=(q,))
    p1.start()
    p1.join()
    print('主进程')
'''
子进程从队列当中拿到的数据: 主进程添加的数据a
主进程
'''
"""
上述代码我们得出结论:主进程和子进程可以依靠队列来进行数据交互
"""

from multiprocessing import Process, Queue

def product(q):
    q.put('子进程p2添加进队列的数据a')

def consumer(q):
    print('子进程p1从队列中拿到的数据:', q.get())

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=consumer, args=(q,))
    p2 = Process(target=product, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print('主进程')
'''
子进程p1从队列中拿到的数据: 子进程p2添加进队列的数据a
主进程
'''
"""
不仅子进程和主进程之间可以通过队列数据交互,子进程自检也可以进行数据交互
"""

8.生产者消费者模型(主要用在爬虫领域)

1.生产者:负责生产数据的'人';eg:爬虫爬取到的数据写入excel的过程。
        
2.消费者:负责处理数据的'人'。
"""
该模型除了上述两种类型,还应该有消息队列,生产者和消费者无直接关联,消息队列可以让生产者和消费者产生关联,并且可以对生产者产生的数据进行存储,也避免了两者需要同时工作的现象。消息队列也可以是数据库,文件,只要是能提供保存和提取服务的都可以
"""

9.进程对象的多种方法

1.在cmd窗口输入tasklist能看到系统给每一个进程分配的进程号,进程号和端口号一样都是为了方便管理
from multiprocessing import Process, current_process

def task():
   print(current_process())
   print(current_process().pid) # 获取子进程进程号

if __name__ == '__main__':
   print(current_process())  
   print(current_process().pid) # 获取主进程进程号
   p1 = Process(target=task)
   p1.start()
   p1.join()
   print('主进程')
'''
<_MainProcess(MainProcess, started)>
48692
<Process(Process-1, started)>
49216
主进程
'''

2.获取进程号也可以选用os模块中的os.getpid()方法,os.getppid()是查看父进程的进程号,其中子进程的父进程号和主进程号一致,因为主进程就是子进程的父进程。主进程的父进程是pycharm的进程号。
import os
from multiprocessing import Process

def task():
   print('子进程:', os.getpid())
   print('子进程的父进程', os.getppid())

if __name__ == '__main__':
   p1 = Process(target=task)
   p1.start()
   p1.join()
   print('主进程', os.getpid())
   print('主进程的父进程', os.getppid())

'''
子进程: 47784
子进程的父进程 46788
主进程 46788
主进程的父进程 2976
'''

3.杀死进程:在pycharm中可以用子进程对象.terminate()结束。
import os
from multiprocessing import Process

def task():
    print('子进程:', os.getpid())
    print('子进程的父进程', os.getppid())

if __name__ == '__main__':
    p1 = Process(target=task)
    p1.start()
    p1.terminate()
    print('主进程', os.getpid())
    print('主进程的父进程', os.getppid())

'''
子进程: 47784
子进程的父进程 46788
主进程 46788
主进程的父进程 2976
'''
"""
也可以在cmd窗口用taskkill /F /PID 进程号 来终止
"""

4.判断进程是否存活:
def task():
    print('子进程:', os.getpid())

if __name__ == '__main__':
    p1 = Process(target=task)
    p1.start()
    print(p1.is_alive())  # True
    p1.terminate()
    print(p1.is_alive())  # True
"""
由于终止后程序还在运行,只需要让它睡一下,就会发现已经不再存活
"""
import os
from multiprocessing import Process
import time

def task():
    print('子进程:', os.getpid())

if __name__ == '__main__':
    p1 = Process(target=task)
    p1.start()
    print(p1.is_alive())  # True
    p1.terminate()
    time.sleep(1)
    print(p1.is_alive())  # False

10.守护进程

进程如果有守护进程,它关闭了那么它的守护进程也关闭
from multiprocessing import Process
import time

def task(name):
    print('%s是子进程' % name)
    time.sleep(3)
    print('%s是子进程'% name)

if __name__ == '__main__':
    p1 = Process(target=task, args=('进程1',))
    p1.daemon = True  # p1进程是主进程的守护进程
    p1.start()
    time.sleep(1)
    print('主进程')  # 主进程执行完毕,守护进程还没执行完,就已经结束
'''
进程1是子进程
主进程
'''

11.僵尸进程与孤儿进程

1.僵尸进程:进程执行完毕后并不会立刻销毁所有的数据,会有一些信息短暂保留下来，比如进程号、进程执行时间、进程消耗功率等给父进程查看
ps:所有的进程都会变成僵尸进程

2.孤儿进程:子进程正常运行,父进程意外死亡,操作系统针对孤儿进程会派遣福利院管理。

12.多进程数据错乱问题

模拟抢票软件

from multiprocessing import Process
import time
import json
import random


# 查票
def search(name):
    with open(r'data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    print('%s在查票 当前余票为:%s' % (name, data.get('ticket_num')))


# 买票
def buy(name):
    # 再次确认票
    with open(r'data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    # 模拟网络延迟
    time.sleep(random.randint(1, 3))
    # 判断是否有票 有就买
    if data.get('ticket_num') > 0:
        data['ticket_num'] -= 1
        with open(r'data.json', 'w', encoding='utf8') as f:
            json.dump(data, f)
        print('%s买票成功' % name)
    else:
        print('%s很倒霉 没有抢到票' % name)


def run(name):
    search(name)
    buy(name)


if __name__ == '__main__':
    for i in range(10):
        p = Process(target=run, args=('用户%s'%i, ))
        p.start()
   
"""
多进程操作数据很可能会造成数据错乱>>>:互斥锁
	互斥锁
		将并发变成串行 牺牲了效率但是保障了数据的安全
"""