并发编程-进程

进程的特点

• 动态性：进程是程序的一次执行过程，是临时的，有生命期的，是动态产生，动态消亡的；
• 并发性：任何进程都可以同其他进程一起并发执行；
• 独立性：进程是系统进行资源分配和调度的一个独立单位；
• 结构性：进程由程序、数据和进程控制块三部分组成。
  子进程不一定依赖于父进程，可以父进程结束了，子进程依然存在。

1.开启多进程

两种方式。

• 方式一：调用函数
• 方式二：继承Process

# 方式一
from multiprocessing import Process
import time
import os

def func(args, args2):
    print(args, args2)
    time.sleep(1)
    print('子进程：', os.getpid())
    print('子进程的父进程：', os.getppid())
    print('func')


# 开启一个进程
p = Process(target=func, args=('参数一', '参数二'))  # register, p is a process object
p.start()  # start
print('*'*10)
print('父进程：', os.getpid())  # 查看当前进程的进程号
print('父进程的父进程：', os.getppid())  # 查看当前进程的父进程
# 输出结果：
# **********
# 父进程： 7207
# 父进程的父进程： 1114
# 参数一 参数二
# 子进程： 7208
# 子进程的父进程： 7207
# func

# 方式二：
import os
from multiprocessing import Process

class MyProcess(Process):
    def run(self) -> None:
        print(self.pid)
        print(self.name)
        print('子进程的id', os.getpid())


print('主进程的id：', os.getpid())
p1 = MyProcess()
p1.start()
p2 = MyProcess()
p2.start()

# 方式二：（能传参）
# --> 通过 __init__
from multiprocessing import Process
import os


class MyProcess(Process):
    def __init__(self, arg1, arg2):  # 继承了Process， __init__也要继承父类的__init__
        super().__init__()
        self.arg1 = arg1
        self.arg2 = arg2

    def run(self) -> None:
        print(self.pid)  # 都是在父类Process中init方法中就有的。
        print(self.name)  # 都是在父类Process中init方法中就有的。
        print(self.arg1)


print('主进程的id：', os.getpid())
p1 = MyProcess(1, 3)
p1.start()

2.多进程的join方法

join方法：p.join() 是感知一个子进程的结束，将异步的程序改为同步

from multiprocessing import Process
import os

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

# 开启十个进程，同时开始写，等待全部写完后，展示文件夹中的所有文件
p_list = []
for i in range(10):
    p = Process(target=func, args=('info%s'%i, 'content%s'%i))
    p_list.append(p)
    p.start()
[p.join() for p in p_list]  # 之前的所有进程必须在这里执行完，才会执行下面的代码
print([i for i in os.walk('/Users/yanl/PycharmProjects/FullStack/并发编程')])

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

from multiprocessing import Process
import os


def func():
    global n
    n = 0
    print('子进程id：', os.getpid(), 'n=', n)

n = 100
p = Process(target=func)
p.start()
print('n=', n)

输出结果：
n= 100
子进程id： 7490 n= 0

子进程中更改了全局变量，并不能影响父进程中全局变量的值。进程之间的数据，不通过特殊手段是不能互通的。

4.使用多线程实现socket服务端的并发效果

server端

import socket
from multiprocessing import Process


def server(conn):
    conn.send(('hello').encode('utf-8'))
    msg = conn.recv(1024).decode('utf-8')
    print(msg)
    conn.close()


sk = socket.socket()
sk.bind(('127.0.0.1', 8080))
sk.listen()
while True:
    conn, addr = sk.accept()  # 收到一个连接，就开启一个进程。
    p = Process(target=server, 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)
sendmsg = input('>>>').encode('utf-8')
sk.send(sendmsg)

sk.close()

5.守护进程

守护进程会随着主进程的代码执行完毕而结束。（是主进程的代码 不看其他子进程的执行时间 ）
用法：在p.start()之前添加代码p.daemon=True

from multiprocessing import Process
import time


def func():
    while True:
        time.sleep(0.2)
        print('func 进程还在运行')


p = Process(target=func)
p.daemon = True  # 将子进程设置为守护进程
p.start()
i = 0
while i < 5:
    print('主进程还在运行')
    time.sleep(0.3)
    i += 1

运行结果：
主进程还在运行
主进程还在运行
func 进程还在运行
主进程还在运行
主进程还在运行
func 进程还在运行
主进程还在运行 

当有多个子进程时，守护进程func在主进程代码执行完毕后马上结束，并不等待其他子进程func2执行完。代码如下：

# 多个子进程
from multiprocessing import Process
import time


def func():
    while True:
        time.sleep(0.2)
        print('func 进程还在运行')


def func2():
    time.sleep(6)
    print('func2 刚刚执行完')


p = Process(target=func)
p.daemon = True  # 将子进程设置为守护进程
p.start()
p2 = Process(target=func2).start()

i = 0
while i < 5:
    print('主进程还在运行')
    time.sleep(0.3)
    i += 1

other

• 进程的方法：

p = Process(target=func)
p.join()  # p.join() 是感知一个子进程的结束，将异步的程序改为同步
p.terminate()  # 结束该子进程
p.is_alive()  # 检查该进程是否还活着。真则返回True

• 进程的属性：

p.name  # 返回该进程的名字
p.pid  # 返回该进程的进程号