进程

1.创建进程的两种方式

点击查看代码

from multiprocessing import Process
import time


def test(name):
    print('%s is running'%name)
    time.sleep(3)
    print('%s is over'%name)

"""
windows创建进程会将代码以模块的方式 从上往下执行一遍
linux会直接将代码完完整整的拷贝一份


windows创建进程一定要在if __name__ == '__main__':代码块内创建  否则报错
"""
if __name__ == '__main__':
    p = Process(target=test,args=('egon',))  # 创建一个进程对象
    p.start()  # 告诉操作系统帮你创建一个进程
    print('主')
"""
创建进程就是在内存中重新开辟一块内存空间
将允许产生的代码丢进去
一个进程对应在内存就是一块独立的内存空间

进程与进程之间数据是隔离的 无法直接交互
但是可以通过某些技术实现间接交互
"""

# 创建进程的第二种方式
from multiprocessing import Process
import time


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

    def run(self):
        print('%s is running' % self.name)
        time.sleep(3)
        print('%s is over' % self.name)


if __name__ == '__main__':
    p = MyProcess('egon')
    p.start()
    print('主')

2.进程间通信

点击查看代码

队列:先进先出
堆栈:先进后出
"""
from multiprocessing import Process,Queue,current_process
import time
q = Queue(5) #括号可以传参数，表示最大存储数
q.put('a')  #存放值到队列
q.put('b')
q.put('c')
q.put('d')
q.put('e')
q.put_nowait(6)  #当队列值满了后直接报错，raise full
res1 = q.full()
print(res1) #判断队列是否值已经满了
# q.put('f') #当队列值存储满了以后，程序会卡在这里

q.get()  #获取队列值
q.get()  #获取队列值
q.get()  #获取队列值
q.get()  #获取队列值
res = q.empty() #判断队列的值是否已经取完
print(res)
data = q.get()  #获取队列值
q.get_nowait()  # 取值 没有值不等待直接报错 raise Empty
# data2 = q.get()

print(data2)  #当队列的值取完后，再次取值，不会报错，程序也会卡在这里，等待取值

full
get_nowait
empty
都不适用于多进程的情况

运行结果：
    raise Empty
_queue.Empty
True
False

3.进程间通信IPC机制

点击查看代码

from multiprocessing import Process,Queue

def producer(q):
    q.put('hello GF~')

def consumer(q):
    print(q.get())

if __name__ == '__main__':
    q = Queue()
    p = Process(target=producer,args=(q,))
    c = Process(target=consumer, args=(q,))
    p.start()
    c.start()


"""
子进程放数据 主进程获取数据
两个子进程相互放 取数据
"""
运行结果：
hello GF~

Process finished with exit code 0

4.进程对象及其他方法

点击查看代码

from multiprocessing import Process,current_process
import os
import time


def test(name):
    # print('%s is running'%name,current_process().pid)
    print('%s is running'%name,'子进程%s'%os.getpid(),'父进程%s'%os.getppid())
    time.sleep(3)
    print('%s is over'%name)


if __name__ == '__main__':
    p = Process(target=test,args=('egon',))
    p1 = Process(target=test,args=('jason',))
    p.start()
    p1.start()
    p.join()  # 主进程代码等待子进程运行结束 才继续运行
    p1.join() # 主进程代码等待子进程运行结束 才继续运行
    # p.terminate()  # 杀死当前进程  其实是告诉操作系统帮你杀死一个进程
    time.sleep(0.1)
    print(p.is_alive())  # 判断进程是否存活
    # print('主',current_process().pid)
    print('主',os.getpid(),'主主进程:%s'%os.getppid())

运行结果：
egon is running 子进程2864 父进程11840
jason is running 子进程10292 父进程11840
egon is over
jason is over
False
主 11840 主主进程:4708

Process finished with exit code 0

5.守护进程

点击查看代码

from multiprocessing import Process
import time


def test(name):
    print('%s总管正常活着'%name)
    time.sleep(3)
    print('%s总管正常死亡'%name)


if __name__ == '__main__':
    p = Process(target=test,args=('egon',))
    p.daemon = True  # 将该进程设置为守护进程   这一句话必须放在start语句之前 否则报错
    p.start()
    time.sleep(0.1)
    print('皇帝jason寿正终寝')

运行：
皇帝jason寿正终寝

Process finished with exit code 0

6.进程间数据是隔离的

点击查看代码

from multiprocessing import Process
import time


money = 100
def test():
    global money
    money = 99999999


if __name__ == '__main__':
    p = Process(target=test)
    p.start()
    p.join()
    print(money)
运行：
'''
100

Process finished with exit code 0
'''

7.互斥锁

点击查看代码

from multiprocessing import Process,Lock
import time
import json
#
# # 查票
def search(i):
    with open('data','r',encoding='utf-8') as f:
        data = f.read()
    t_d = json.loads(data)
    print('用户%s查询余票为:%s'%(i,t_d.get('ticket')))
#
# # 买票
def buy(i):
    with open('data','r',encoding='utf-8') as f:
        data = f.read()
    t_d = json.loads(data)
    time.sleep(1)
    if t_d.get('ticket') > 0:
        # 票数减一
        t_d['ticket'] -= 1
        # 更新票数
        with open('data','w',encoding='utf-8') as f:
            json.dump(t_d,f)
        print('用户%s抢票成功'%i)
    else:
        print('没票了')


def run(i,mutex):
    search(i)
    mutex.acquire()
    buy(i)# 抢锁  只要有人抢到了锁 其他人必须等待该人    buy(i)
    mutex.release()  # 释放锁
# 释放锁


if __name__ == '__main__':
    mutex = Lock()  # 生成了一把锁
    for i in range(5):
        p = Process(target=run,args=(i,mutex))
        p.start()
运行：
用户0查询余票为:1
用户1查询余票为:1
用户2查询余票为:1
用户3查询余票为:1
用户4查询余票为:1
用户0抢票成功
没票了
没票了
没票了
没票了

8.生产者消费者模型

点击查看代码

"""
生产者:生产/制造数据的
消费者:消费/处理数据的
例子:做包子的,买包子的
        1.做包子远比买包子的多
        2.做包子的远比包子的少
        供需不平衡的问题
"""
from multiprocessing import Process,Queue,JoinableQueue
import random
import time


def producer(name,food,q):
    for i in range(10):
        data = '%s生产了%s%s'%(name,food,i)
        time.sleep(random.random())
        q.put(data)
        print(data)

def consumer(name,q):
    while True:
        data = q.get()
        if data == None:break
        print('%s吃了%s'%(name,data))
        time.sleep(random.random())
        q.task_done()  # 告诉队列你已经从队列中取出了一个数据 并且处理完毕了



if __name__ == '__main__':
    q = JoinableQueue()

    p = Process(target=producer,args=('大厨tony','馒头',q))

    c = Process(target=consumer,args=('吃货jarry',q))

    p.start()
    p1.start()
    c.daemon = True
    c1.daemon = True
    c.start()
    c1.start()
    p.join()
    p1.join()

    q.join()  # 等到队列中数据全部取出
运行：
大厨tony生产了馒头0
吃货jerry吃了大厨tony生产了馒头0
大厨tony生产了馒头1
大厨tony生产了馒头2
大厨tony生产了馒头3
吃货jerry吃了大厨tony生产了馒头1
大厨tony生产了馒头4
吃货jerry吃了大厨tony生产了馒头2
吃货jerry吃了大厨tony生产了馒头3
吃货jerry吃了大厨tony生产了馒头4

Process finished with exit code 0