Python并发编程基础 №② 进程 进程间的数据隔离 守护进程 进程锁

1、进程的常规使用

import time
from multiprocessing import Process


def func(arg1):
    print('func is running, arg1 is:  ', arg1)
    time.sleep(2)
    print('func continue running!')


if __name__ == '__main__': # windows中运行
    p = Process(target=func, args=('name',))
    p.start()
    print('main process is running here!')

2、进程中的方法：join

import os, time
from multiprocessing import Process


def func():
    print('子进程%s在运行'%os.getpid())
    time.sleep(1)
    print('子进程%s继续在运行' % os.getpid())


if __name__ == '__main__':
    print('主进程:', os.getpid(), '在运行！')
    p = Process(target=func)
    p.start()

    # 是感知一个子进程的结束
    p.join()  # 将异步变同步，让主进程等待该子进程运行，直到结束。

    print('====== : 运行完了')

 

3、生成多个进程的例子，并使用join

import os
from multiprocessing import Process


def write(filename, content):
    print('it is writing', os.getpid())
    with open(filename, 'w') as f:
        f.write(content * 10 * '*')


if __name__ == '__main__':

    p_li = []
    for i in range(10):
        p = Process(target=write, args=('file_no%d'%i, i))
        p_li.append(p)
        p.start()

    [p.join() for p in p_li]  # 等待所有的进程运行完
    print(os.listdir(os.getcwd()))  # 查看当前目录下所有的子目录名称，是一个列表。
    print([ i for i in os.walk(os.getcwd())])  # 列表推导式，列表中含元组  #[('D:\\python_bases\\day36', [], todo 是上面的列表
    print('主进程：', os.getpid(), '马上结束运行。。。。')

4、使用继承来使用进程

from multiprocessing import Process
import os


class MyProcess(Process):
    """
    定义自己的额进程类，继承Process
    如果想实现初始化方法，必须带上Process的初始化方法
    """
    def __init__(self, arg1, arg2):
        super().__init__()  # 必须加，否则报错
        self.arg1 = arg1
        self.arg2 = arg2

    def run(self):
        print("进程开启，id为：",os.getpid(),self.arg1, self.arg2)


if __name__ == '__main__':
    print('主线程的id:', os.getpid())
    mp1 = MyProcess(1, 2)
    mp1.start()  # 如果run就和主进程id一样了！

    mp2 = MyProcess(3, 4)
    mp2.start()

5、进程间的数据隔离问题

import os
from multiprocessing import Process

n = 1000


def show_data_independ(num):
    """
    演示进程间的数据隔离
    :param num: n
    :return: None
    """
    global n         # 声明了一个全局变量
    #n = 10           # 重新定义了一个n
    print('主进程传递过的n的值是：', num)
    print('子进程中的n的值是：', n)


if __name__ == '__main__':
    n = 100
    p = Process(target=show_data_independ, args=(n,))
    p.start()
    p.join()
    print(os.getpid(), n)

6、守护进程的开启

import os, time
from multiprocessing import Process


def process_son_run():
    """
    非守护进程演示
    主进程已经结束运行，但是其子进程还在继续运行，这我默认状态
    :return:
    """
    while 1:
        time.sleep(0.2)
        print('子进程%s正在运行。。。。。。'%os.getpid())

def son_process_walk():
    print('son_process_walk   started')
    time.sleep(8)
    print('son_process_walk   finished')


if __name__ == '__main__':

    p = Process(target=process_son_run)

    # 必须在start前，如果开启,开启守护进程！（即主进程关闭则子进程一起关闭）
    p.daemon = True
    p.start()

    p2 = Process(target=son_process_walk)
    p2.start()
    p2.terminate()    # 结束一个子进程
    print(p.name, p.pid)  # 不是马上结束，需要一个过程！ Process-1 13068
    time.sleep(1)
    print(p2.is_alive())   # 检验一个进程是否还活着
    print('主进程结束运行了！')

# 守护进程 会 随着 主进程的代码执行完毕 而 结束
# 在主进程内结束一个子进程 p.terminate()
    #  结束一个进程不是在执行方法之后立即生效,需要一个操作系统响应的过程
# 检验一个进程是否活着的状态 p.is_alive()
# p.name p.pid 这个进程的名字和进程号

7、进程锁的演示

import time,os,json
from multiprocessing import Process, Lock

'''
模拟网络购票：
有网络延时的情况
'''


def look_left(i):
    """
    看还剩多少票
    :return:
    """
    with open('ticket') as f:
        dic = json.load(f)
        print('到杭州的火车票还剩%s张！'%dic['left'])


def buy(i, lock):
    # lock.acquire()
    time.sleep(i * 1)
    # time.sleep(1)   如果等待时间太短，都会买到票，没法子，cpu6核的！
    with open('ticket') as f:
        dic = json.load(f)

    if dic['left'] > 0:
        print('\033[31m购买者%s买到票了\033[0m！' % i)
        dic['left'] -= 1
    else:
        print('\033[32m购买者%s没买到票了\033[0m！' % i)

    time.sleep(2)
    with open('ticket', 'w') as f:
        json.dump(dic, f)
    # lock.release()
if __name__ == '__main__':

    # for i in range(10):
    #    p = Process(target=look_left, args=(i,))
    #    p.start()
    lock = Lock()

    for i in range(10):
        Process(target=buy, args=(i, lock)).start()


# 没加锁前：1张票有三个人抢到
# todo 购买者0买到票了！
# todo 购买者1买到票了！
# todo 购买者2买到票了！
'''
购买者3没买到票了！
购买者4没买到票了！
购买者5没买到票了！
购买者6没买到票了！
购买者7没买到票了！
购买者8没买到票了！
购买者9没买到票了！
'''

9、sock中server端并发提供服务

 server端的代码：

import socket
from multiprocessing import Process


def serve(conn):
    msg = conn.recv(1024).decode('utf-8')
    print(msg)
    conn.close()


if __name__ == '__main__':

    sk = socket.socket()
    sk.bind(('127.0.0.1', 8888))
    sk.listen()
    # todo 如果在这sk.accept() 会将cpu资源耗尽！！！
    try:
        while True:
            conn, addr = sk.accept()
            conn.send('你好吗？'.encode('utf-8'))
            Process(target=serve, args=(conn,)).start()
    except:
        sk.close()

client端的代码：

import socket

sk = socket.socket()
sk.connect(('127.0.0.1', 8888))

msg = sk.recv(1024).decode('utf-8')
print(msg)

ipt = input('>>>').encode('utf-8')
sk.send(ipt)

sk.close()