进程编程

Posted 2020-10-04 wateligx

进程与程序的区别

程序只是一堆代码，进程指的是程序的运行过程

并发与并行的区别

比如一台计算机有4个CPU，然后分别运行了4个程序，这种叫做并行。

当一个CPU要运行4个程序，叫并发。

如何实现单核的并发效果：

例如：某人正在做饭，洗衣服，拖地，首先他要先烧水，在烧的过程中，他决定去洗衣服，把衣服放到洗衣机里面，打开开关后，水

还没有烧开于是他又去拖了个地，拖到半途中，水开了，他接着去做饭。。。。。用等待时间去干别的事情，是有某人决定，相对于

计算机来说，操作系统便实现协调管理、调度进程，并且将多个进程对硬件的竞争变得有序。

同步异步

同步和异步关注的是消息通信机制
所谓同步，就是在发出一个调用时，在没有得到结果之前，该调用就不返回。但是一旦调用返回，就得到返回值了。
换句话说，就是由调用者主动等待这个调用的结果。

而异步则是相反，调用在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果。而是在*调用*发出后，*被调用者*通过状态、通知来通知调用者，或通过回调函数处理这个调用。

一、进程是如何创建的

1、系统初始化（查看进程linux中用ps命令，windows中用任务管理器，前台进程负责与用户交互，后台运行的

进程与用户无关，运行在后台并且只在需要时才唤醒的进程，称为守护进程）

2、一个进程在运行过程中开启子进程（如nginx开启多进程，os.fork,subprocess.Popen等）

3、用户的交互式请求，而创建一个新进程（如双击QQ）

4、一个批处理作业的初始化（只在大型机的批处理系统中应用）

无论哪一种，进程的创建都是向操作系统发起的请求，新进程的创建都是由一个已经存在的进程执行了一个用于创建进程的系统调用而创建的。

 

二、进程的终止

1、正常退出（点击X）

2、出错退出（python a.py，a.py不存在）

3、严重错误（如引用不存在的内存）

4、被其他进程杀死

 

 python下如何创建进程

#方法一
from multiprocessing import Process
import time
def work(name):
    print(‘task <%s> is runing‘%name)
    time.sleep(2)
    print(‘task <%s> is done‘%name)

#由于产生的两个子进程共享终端，所以会发生争抢
if __name__ == ‘__main__‘:#创建进程必须在main中
    p1 = Process(target=work,args=(‘wate‘,))
    p2 = Process(target=work, kwargs={‘name‘:‘egon‘},))
    p1.start()#开启进程
    p2.start()#开启进程
    print(‘主‘)

#方法二
from  multiprocessing import Process
import time

class MyProcess(Process):#继承Process类
    def __init__(self,name):
        super().__init__()#继承父类的init方法
        self.name = name

    def run(self):#这种开启子进程的方法必须要有run方法
        print(‘task <%s> is runing‘ % self.name)
        time.sleep(2)
        print(‘task <%s> is done‘ % self.name)

if __name__ == ‘__main__‘:
    p1 = MyProcess(‘wate‘)
    p1.start()#执行MyProcess.run方法
    p2 = MyProcess(‘egon‘)
    p2.start()
    print(‘主‘)

将无并发的套接字通过进程实现并发

#服务端
from socket import *
from multiprocessing import Process

s = socket(AF_INET,SOCK_STREAM)
s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)#端口复用
s.bind((‘127.0.0.1‘,8080))
s.listen(5)


def walk(conn,addr):
    while True:
        try:
            data = conn.recv(1024)
            if not data: break
            conn.send(data.upper())
        except Exception:
            break
    conn.close()

if __name__ == ‘__main__‘:
    while True:
        conn,addr = s.accept()
        #开启子进程，没接收到一个链接就交给子进程取循环收发消息
        p = Process(target=walk,args=(conn,addr))
        p.start()
    s.close()

#客户端
from  socket import *
c = socket(AF_INET,SOCK_STREAM)
c.connect((‘127.0.0.1‘,8080))

while True:
    msg = input(‘>>>‘)
    if not msg:continue
    c.send(msg.encode(‘utf-8‘))
    data = c.recv(1024)
    print(data.decode(‘utf-8‘))

进程的join方法

import time
from multiprocessing import Process
def walk(name):
    print(‘task <%s> is runing‘%name)
    time.sleep(2)
    print(‘task <%s> is done‘%name)

if __name__ == ‘__main__‘:
    p1 = Process(target=walk,args=(‘egon‘,))
    p2 = Process(target=walk,args=(‘egon‘,))
    p3 = Process(target=walk,args=(‘egon‘,))
    p_l = [p1,p2,p3]
    for p in p_l:
        p.start()
    for p in p_l:
        p.join()#主进程等所有子进程运行结束后才会执行

    print(‘主‘)

关于进程的其他方法

p1.terminate（）#终止进程，不建议使用（当子进程又产生子进程时，执行这个会产生僵尸进程）

p1.is_alive()#进程是否存活

p1.pid #p1对象产生进程的pid，也可在子进程中使用os.getpid()查看子进程的pid，os.getppid()查看父id

守护进程　

1、守护进程会在主进程的代码执行结束后终止

2、守护进程中无法再产生子进程

from multiprocessing import Process
import time
def work(name):
    print(‘------>%s‘%name)
    time.sleep(2)
    print(‘=====>%s‘%name)
if __name__ == ‘__main__‘:
    p1 = Process(target=work,args=(‘egon‘,))
    p1.daemon = True#守护进程
    p1.start()
    print(‘主‘)
#运行结果：主进程执行完成，守护子进程还未执行，便结束了