python基础-Process创建进程、join方法、实现ftp多进程

进程概念

获取进程id

并行并发概念

Process类的介绍

Process类的其他方法

join方法

利用多进程实现ftp套接字

进程概念

进程即正在执行的一个过程或者说一个任务。进程是对正在运行程序的一个抽象，而负责执行任务则是cpu

程序仅仅只是一堆代码而已，而进程指的是程序的运行过程。

进程的概念起源于操作系统，进程的创建，调度管理都归操作系统管

一 操作系统的作用：

1：隐藏丑陋复杂的硬件接口，提供良好的抽象接口

2：管理、调度进程，并且将多个进程对硬件的竞争变得有序

二 多道技术：

1.产生背景：针对单核，实现并发

ps：

现在的主机一般是多核，那么每个核都会利用多道技术

有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个

cpu中的任意一个，具体由操作系统调度算法决定。

2.空间上的复用：如内存中同时有多道程序
3.时间上的复用：复用一个cpu的时间片
强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样
才能保证下次切换回来时，能基于上次切走的位置继续运行

获取进程id

getpid是获得当前进程的进程号

getppid是获得当前进程的父进程的进程号

import time,os
print(os.getpid(),os.getppid())
time.sleep(1000)

输出如下：

1512 12032

并行、并发概念

一 并发：单个cpu+多道技术就可以实现并发，（并行也属于并发）

二 并行：同时运行，只有具备多个cpu才能实现并行

有四个核，六个任务，这样同一时间有四个任务被执行，假设分别被分配给了cpu1，cpu2，cpu3，cpu4，一旦任务1遇到I/O就被迫中断执行，此时任务5就拿到cpu1的时间片去执行，而一旦任务1的I/O结束了，操作系统会重新调用它(需知进程的调度、分配给哪个cpu运行，由操作系统说了算)，可能被分配给四个cpu中的任意一个去执行

Process类的介绍

p.start() #只是在给操作系统发了一个信号，让操作系统去开进程（申请内存+拷贝父进程的地址空间）

方式一：

from multiprocessing import Process
import time

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

if __name__ == '__main__': #在windows系统下，开子进程的代码必须写到这一行下面
p=Process(target=task,args=('safly1',))
p.start() #只是在给操作系统发了一个信号，让操作系统去开进程（申请内存+拷贝父进程的地址空间）

p1 = Process(target=task, kwargs={"name":"safly2"})
p1.start()
print('主')

输出如下：

主
safly1 is running
safly2 is running

方式二：

from multiprocessing import Process
import time

class Myprocess(Process):
def __init__(self,name):
super().__init__()
self.name=name
def run(self):
time.sleep(3)
print('%s is running' % self.name)

if __name__ == '__main__':  # 在windows系统下，开子进程的代码必须写到这一行下面
p = Myprocess('safly')
p.start()  # p.run()
print('主')

输出如下：

主
safly is running

Process类的其他方法

from multiprocessing import Process
import time, random
def task():
print('孙子运行了')
time.sleep(3)

def piao(name):
print('%s is piaoing' % name)
time.sleep(random.randint(1, 3))
print('%s is done' % name)
p=Process(target=task,)
p.start()

if __name__ == '__main__':
p1=Process(target=piao,args=('alex',),name='xxxxxxxx')
p1.start()
print(p1.name)
print(p1.pid)

print(p1.is_alive())
print('主')

输出如下：

E:\python\python_sdk\python.exe E:/python/py_pro/3_Process对象的属性与方法.py
xxxxxxxx
11816
True
主
alex is piaoing
alex is done
孙子运行了

Process finished with exit code 0

join方法

join：主进程等，等待子进程结束

from multiprocessing import Process
import time,random

def piao(name):
print('%s is piaoing' %name)
time.sleep(random.randint(1,3))
print('%s is done' %name)

if __name__ == '__main__':
p1=Process(target=piao,args=('alex',))
p2=Process(target=piao,args=('wxx',))
p3=Process(target=piao,args=('yxx',))

p1.start()
p2.start()
p3.start()

p3.join()  # join(p)
p1.join() #join(p)
p2.join() #join(p)

print('主')

输出如下：

alex is piaoing
wxx is piaoing
yxx is piaoing
alex is done
wxx is done
yxx is done
主

进程只要start就会在开始运行了,所以p1-p3.start()时,系统中已经有3个并发的进程了

而我们p1.join()是在等p1结束,没错p1只要不结束主线程就会一直卡在原地,这也是问题的关键

join是让主线程等,而p1-p3仍然是并发执行的,p1.join的时候,其余p2,p3仍然在运行,等#p1.join结束,可能p2,p3早已经结束了,这样p2.join,p3.join直接通过检测，无需等待

所以3个join花费的总时间仍然是耗费时间最长的那个进程运行的时间

上述例子可以简写成如下：

from multiprocessing import Process
import time,random

def piao(name):
print('%s is piaoing' %name)
time.sleep(random.randint(1,3))
print('%s is done' %name)

if __name__ == '__main__':

p1=Process(target=piao,args=('alex',))
p2=Process(target=piao,args=('wxx',))
p3=Process(target=piao,args=('yxx',))
p_l=[p1,p2,p3]
for p in p_l:
p.start()

for p in p_l:
p.join()

print('主')

利用多进程实现ftp套接字

我们之前写过非多进程的tcp套接字通信，这里在贴出代码来看下

server

import socket
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind(("127.0.0.1",8081))
server.listen(5)
while True:
conn,addr = server.accept()
while True:
data = conn.recv(1024)
if not data:break

dataStr = data.decode("utf-8")
print(dataStr)

conn.send(dataStr.upper().encode("utf-8"))

conn.close()

server.close()

client

import socket
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(("127.0.0.1",8081))

while True:
msg = input("请输入：")
if not msg:continue

client.send(msg.encode("utf-8"))
data = client.recv(1024)
print(data.decode("utf-8"))
client.close()

我们要为server端添加多进程（client不做修改）

import socket
from multiprocessing import Process

def task(conn,addr):
while True:
try:
msg = conn.recv(1024)
if not msg:break
conn.send(msg.upper())
except ConnectionResetError:
break

if __name__ == "__main__":
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(("127.0.0.1", 6087))
server.listen(5)
while True:
conn, addr = server.accept()
p = Process(target=task,args=(conn,addr))
p.start()