并发编程笔记(1)——多进程、同步/异步/阻塞/非阻塞、守护进程、进程锁

内容目录

操作系统的历史
进程

内容详细：

操作系统：

一：隐藏了丑陋的硬件调用接口，为应用程序员提供调用硬件资源的更好，更简单，更清晰的模型（系统调用接口）。应用程序员有了这些接口后，就不用再考虑操作硬件的细节，专心开发自己的应用程序即可。
例如：操作系统提供了文件这个抽象概念，对文件的操作就是对磁盘的操作，有了文件我们无需再去考虑关于磁盘的读写控制（比如控制磁盘转动，移动磁头读写数据等细节），
二：将应用程序对硬件资源的竞态请求变得有序化
例如：很多应用软件其实是共享一套计算机硬件，比方说有可能有三个应用程序同时需要申请打印机来输出内容，那么a程序竞争到了打印机资源就打印，然后可能是b竞争到打印机资源，也可能是c，这就导致了无序，打印机可能打印一段a的内容然后又去打印c...,操作系统的一个功能就是将这种无序变得有序。

进程：

隐藏丑陋复杂的硬件接口，提供良好的抽象接口
管理、调度进程，并且将多个进程对硬件的竞争变得有序

同步/异步/阻塞/非阻塞

多进程模块：multiprocessing

from multiprocessing import Process #多进程必用模块
def func():
    print(12345)

if __name__ == '__main__':
    p = Process(target=func)    # 把一个函数注册进这个进程里面
    # p是一个进程对象，还没有启动进程
    p.start()   #进程启动
    print('*'*10)

#多进程：带参数的函数
from multiprocessing import Process
def func(args):
    print(args)

if __name__ == '__main__':
    p = Process(target=func,args=('参数',))  #传参时必须是元组
    p.start()   #进程启动

os.pid：获取当前进程号

import os
from multiprocessing import Process #多进程必用模块
def func():
    print(12345)
    print('子进程：',os.getpid())
    print('子进程的父进程：',os.getppid())

if __name__ == '__main__':
    p = Process(target=func)    # 把一个函数注册进这个进程里面
    # p是一个进程对象，还没有启动进程
    p.start()   #进程启动
    print('*'*10)
    print('主进程：',os.getpid())
    print('主进程的父进程：',os.getppid())

当前程序为主进程，如果新建了进程，并把函数注册进了该进程，则该进程与主进程同时运行。
主进程的父进程为pycharm

进程的生命周期

主进程
子进程
开启了子进程的主进程：
- 主进程的代码如果长，等待主进程自己的代码执行结束
- 子进程的执行时间长，主进程会在主进程代码执行完毕后等待子进程执行完毕之后，主进程才结束

进程中join的用法

感知一个子程序的结束，将异步程序改为同步程序

import time
from multiprocessing import Process
def func(arg1,arg2):
    print('*' * arg1)
    time.sleep(5)
    print('*' * arg2)


if __name__ == '__main__':
    p = Process(target=func,args=(5,10))#传参时必须是元组
    p.start()   #进程启动
    p.join()    #是感知一个子程序的结束，将异步程序改为同步
    print('=========:执行结束')

多个子进程执行完后，主程序再立即执行，需要用到join方法

from multiprocessing import Process

def func(arg1,arg2):
    print('*'*arg1)
    print('='*arg2)

if __name__ == '__main__':
    p_list = []
    for i in range(10):
        p = Process(target=func,args=(10*i,20*i))
        p_list.append(p)
        p.start()
    [p.join() for p in p_list]  #p.join()相当于把子程序都执行完了，再运行主程序
    #子程序由异步变成同步
    print('主程序执行完毕')

应用场景：写文件：同时开启500个进程写文件，异步执行，写文件执行完毕后打印目录

注意，写文件执行完毕后需要用到join方法变为同步，然后再执行打印目录命令

import os
from multiprocessing import Process

def func(filename,content):
    with open(filename,'w')as f:
        f.write(content*10*'*')

if __name__ == '__main__':
    p_list = []
    for i in range(1,5):
        p = Process(target=func,args=('info%s'%i,i))
        p_list.append(p)
        p.start()
    [p.join() for p in p_list]  #之前所有进程必须都执行完才能执行下面的代码
    print([i for i in os.walk(r'D:\pycharm_project\python36')])

多个子程序运行

启动多个子程序调用函数，同时执行

import time
from multiprocessing import Process

def func(arg1,arg2):
    print('*'*arg1)
    time.sleep(5)
    print('*'*arg2)

if __name__ == '__main__':          #启用多个子程序同时运行
    p1 = Process(target=func,args=(3,10))            #传参
    p1.start()                  #启动子进程
    p2 = Process(target=func,args=(4,11))
    p2.start()
    p3 = Process(target=func,args=(5,12))
    p3.start()

也可以使用for循环的方法

import time
from multiprocessing import Process

def func(arg1,arg2):
    print('*'*arg1)
    time.sleep(5)
    print('*'*arg2)

if __name__ == '__main__':
    for i in range(4):			#使用for循环该进程，相当于开启了4个子进程
        p1 = Process(target=func,args=(3,10))
        p1.start()

继承类的多线程方法

自定义类，必须继承Process类
必须实现一个run方法，run方法中是在子进程中执行的代码

start方法自动处理run方法

import os
from multiprocessing import Process

class MyProcess(Process):
    def run(self):
        print(os.getpid())        #要执行的子进程方法

if __name__ == '__main__':
    print('主：',os.getpid())
    p1 = MyProcess()        #实例化类
    p1.start()              #start方法自动处理run方法
    p2 = MyProcess()        #实例化类
    p2.start()              #启动第二个子进程

# 自定义类，必须继承Process类
# 必须实现一个run方法，run方法中是在子进程中执行的代码

传参的方式

import os
from multiprocessing import Process

class MyProcess(Process):
    def __init__(self,arg1,arg2):
        super().__init__()      
        self.arg1 = arg1
        self.arg2 = arg2


    def run(self):
        print(self.pid)
        print(self.name)
        print(self.arg1)
        print(self.arg2)

if __name__ == '__main__':
    print('主：',os.getpid())
    p1 = MyProcess(1,2)        #实例化类
    p1.start()              #启动该子进程
    p2 = MyProcess(3,4)        #实例化类
    p2.start()              #启动第二个子进程

多进程之间的数据隔离问题

子进程中的数据无法修改主进程中的数据

import os
from multiprocessing import Process

def func():
    global n        #声明了一个全局变量
    n = 0           #重新定义一个全局变量的n
    print('子进程pid:%s'%os.getpid(),n)

if __name__ == '__main__':  #windows系统下必须使用main
    n = 100
    p = Process(target=func)
    p.start()
    p.join()
    print('主进程pid:%s'%os.getpid(),n)	

#结果为：
子进程pid:432 0			#在子进程中声明了修改一个全局变量，但是主进程的变量并没有发生改变
主进程pid:6696 100

socket多进程示例：

开启多个client端，实现多并发

待优化：多进程会增加服务器内存损耗

# server:
import socket
from multiprocessing import Process

def serve(conn):
    ret = '你好'.encode('utf-8')
    conn.send(ret)
    msg = conn.recv(1024).decode('utf-8')
    print(msg)
    conn.close()

if __name__ == '__main__':
    sk = socket.socket()
    sk.bind(('127.0.0.1',8080))
    sk.listen()
    while True:
        conn,addr = sk.accept()
        p = Process(target=serve,args=(conn,))
        p.start()
    sk.close()
    
# client:
import socket

sk = socket.socket()
sk.connect(('127.0.0.1',8080))
msg = sk.recv(1024).decode('utf-8')
print(msg)
msg2 = input('>>>').encode('utf-8')
sk.send(msg2)
sk.close()

守护进程

守护进程会随着主进程的代码执行完毕而结束,而不是主进程结束

一定是在子进程start之前设置

import time
from multiprocessing import Process

def func():
    while True:
        time.sleep(0.2)
        print('我还活着')

def func2():
    print('in func2 start')
    time.sleep(8)
    print('in func2 finished')

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True         #设置该子进程为守护进程
    p.start()
    p2 = Process(target=func2)
    p2.start()
    i = 0
    while i < 5:
        print('我是socket server')
        time.sleep(1)
        i+=1
# func随着主进程的代码执行结束而结束，而func2子进程继续执行，执行完毕后，主进程整体结束并关闭

强制结束子进程

在主进程内结束一个子进程p.terminate()

结束一个进程不会立即生效，需要操作系统响应的过程

import time
from multiprocessing import Process

def func():
    while True:
        time.sleep(0.2)
        print('我还活着')

def func2():
    print('in func2 start')
    time.sleep(5)
    print('in func2 finished')

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True         #设置该子进程为守护进程
    p.start()
    p2 = Process(target=func2)
    p2.start()
    p2.terminate()          #结束一个子进程
    print(p2.is_alive())    #立即检验子进程存活状态，此时子进程活着，因为执行后需要操作系统响应的过程
    time.sleep(1)
    print(p2.is_alive())    #检验一个进程是否还活着（True/Flase）
    print(p.name)           #输出子进程的名字

判断子进程是否存活：

p.is_alive() -------进程中的方法(True / Flase)
p.name -------输出子进程的名字

进程锁（重点）

必须保证数据安全，所以异步变为同步执行修改数据的代码
- 关键代码加锁
- 进程1来了后先拿钥匙进入代码，后续进程为阻塞状态
- 进程1执行关键代码，执行完毕后把钥匙归还
- 此时进程2可以拿到钥匙了，进入关键代码，后续进程为阻塞状态
- 依次循环，直到最后一个进程结束。

进程锁应用：显示余票和买票

#ticket文件代码：
{"ticket": 1}

#主程序代码：
import json
import time
from multiprocessing import Process
from multiprocessing import Lock        #启用进程锁

def show(i):
    with open('ticket')as f:
        dic = json.load(f)
        time.sleep(0.1)         #模拟拿数据时的网络延迟
    print('余票：%s'%dic['ticket'])

def buy_ticket(i,lock):
    lock.acquire()  #拿钥匙进门，只能拿钥匙的进程进去，其他进程为阻塞状态，直到还钥匙为止
    with open('ticket')as f:
        dic = json.load(f)
        time.sleep(0.2)
    if dic['ticket'] > 0:
        dic['ticket'] -= 1
        print('\033[32m%s买到票了\033[0m'%i)
    else:
        print('\033[31m%s没票了\033[0m'%i)
    time.sleep(0.1)
    with open('ticket','w') as f:
        json.dump(dic,f)
    lock.release()  #还进程锁的钥匙，此时下一个阻塞进程进场

if __name__ == '__main__':
    for i in range(10):
        p = Process(target=show,args=(i,))
        p.start()
    lock = Lock()           #拿到锁对象
    for i in range(10):
        p = Process(target=buy_ticket,args=(i,lock))
        p.start()