python之路--进程内容补充

一. 进程的其他方法

　　进程id, 进程名字, 查看进程是否活着(is_alive()), terminate()发送结束进程的信号

import time
import os
from multiprocessing import Process

def f1():
    print('子进程的pid',os.getpid())
    print('降龙十八掌天下第一')
def f2():
    print('六脉神剑举世无双')

if __name__ == '__main__':
    p1 = Process(target=f1,name='我是进程1')
    p2 = Process(target=f2,)
    p1.start()
    p2.start()
    print(p1.name) # 我是进程1
    print('子进程的pid',p1.pid)
    print('父进程的id',os.getpid())

def f1():
    time.sleep(3)
    print('子进程1号')

if __name__ == '__main__':
    p = Process(target=f1,)
    p.start()
    print(p.is_alive()) # True, 判断进程是否活着
    p.terminate()  # 给系统发送一个结束进程的信号
    time.sleep(0.5)  # 为了让避免并发导致的下面结果不准
    print(p.is_alive())  # False

二 . 僵尸进程和孤儿进程(了解)

　　　僵尸进程可以理解为一些进程垃圾, 没有实际作用, 但是在占用着空间, 当这些进程的父进程正常关闭的时候会清楚这些僵尸进程,

　　　孤儿进程也是一些进程垃圾, 只不过是当父进程非正常关闭的时候, 这些垃圾需要被最上级进程清理.

三 . 验证进程之间是空间隔离的

from multiprocessing import Process
num = 100
def f1():
    global num
    num = 3
    print('子进程中的num',num)

if __name__ == '__main__':
    p = Process(target=f1,)
    p.start()  # 子进程中的num 3
    p.join()
    print('主进程中的num',num)  # 主进程中的num 100

　　

五 . 守护进程

import time
from multiprocessing import Process

def f1():
    time.sleep(1)
    print('我是沉睡1秒的子进程')
    time.sleep(3)
    print('我是沉睡3秒子进程') # 打印不出来
def f2():
    time.sleep(1)
    print('我是普通的子进程')

if __name__ == '__main__':
    p = Process(target=f1,)
    # 将该进程设置为守护进程,必须写在start之前,
    # 意思如果我的主进程代码运行结束了,你这个子进程不管运行到什么地方,都直接结束
    p.daemon = True
    p.start()
    # 开启一个普通的子进程来验证一下守护进程的结束只和主进程的代码运行结束有关系,
    # 而整个程序的结束需要主进程和普通的子进程的代码都运行结束才结束
    p2 = Process(target=f2,)
    p2.start()
    time.sleep(2)
    print('====','我是主进程')
# f1 只能打印出我是沉睡1秒的子进程,
# 主进程打印出==== 我是主进程,然后打印出我是普通的子进程

六 . 进程锁(同步锁/互斥锁) (非常重要)

　　 保证了数据安全,但是牺牲了效率,假锁的这段代码变成了(同步)串行执行的状态

　进程锁就是为了保证数据安全, 比如说抢票如果只剩一张票的话,很多人同时访问都能看到只剩一张票,如果不用进程锁的数据就会发生错误.

import time
from multiprocessing import Process,Lock
def show_ticket(i):
    with open('ticket','r',encoding='utf-8') as f:
        ticket_data = f.read() # 文件中的数据{'count': 1}
    t_data = eval(ticket_data)
    print('%s查询剩余票数为%s'%(i,t_data['count']))
def get_ticket(i,l1):
    # 上锁,所有人只能抢这一个锁,只有抢到了才能继续执行,避免了由于并发导致的数据不准
    l1.acquire()
    with open('ticket', 'r', encoding='utf-8') as f:
        ticket_data = f.read()
        # print(ticket_data)
    t_data = eval(ticket_data)
    if t_data['count'] > 0:
        t_data['count'] -= 1
        print('%s抢票成功' % i)
        time.sleep(0.2)
        with open('ticket', 'w',) as f:
            f.write(str(t_data))
    else:
        print('没票了!!!')
    # 解锁,解锁之后才能重新抢锁
    l1.release()
if __name__ == '__main__':
    l1 = Lock()
    for i in range(10):
        p1 = Process(target=show_ticket,args=(i,))
        p1.start()
    for i in range(10):
        p2 = Process(target=get_ticket,args=(i,l1) )
        p2.start()

def f1(i,lic):
    with lic:  # 直接完成了上锁与解锁的过程
        time.sleep(1)
        print(i)

if __name__ == '__main__':
    lic = Lock()
    for i in range(5):
        p = Process(target=f1, args=(i,lic))
        p.start()

六 . 队列

from multiprocessing import Process,Queue
q = Queue(3)
q.put('乔峰')
q.put('段誉')
q.put('虚竹')
print(q.get())
print(q.get())
print(q.get())
try:
    # 为了不等待直接执行下面的代码 如果是q.get()程序就会在这一直等着直到再次出现q.put()
    q.get_nowait()
except:
    print('队列拿空了')
print('还有东西吗?')

# 基于队列的通信
def f1(q):
    q.put('约不约?')
if __name__ == '__main__':
    q = Queue(3)
    p = Process(target=f1,args=(q,))
    p.start()
    son_p_msg = q.get()
    print('来自子进程的消息:', son_p_msg) # 来自子进程的消息: 约不约?

七 .  基于队列的生产者消费者模型

import time
from multiprocessing import Process,Queue,JoinableQueue
def producer(q):
    for i in range(10):
        time.sleep(0.2)
        s = '大包子%s号' % i
        print('新鲜出炉' + s)
        q.put(s)
    # 这个q.join 是 JoinableQueue 里面的join
    q.join() #就等着task_done()信号的数量,和我put进去的数量相同时,才继续执行
    print('所有的任务都被处理了,继续潜行吧骚年们')

def consumer(q):
    while 1:
        time.sleep(0.5)
        baozi = q.get()
        print(baozi+'被吃了')
        q.task_done()  #给队列发送一个取出的这个任务已经处理完毕的信号

if __name__ == '__main__':
    q = JoinableQueue(30) #同样是一个长度为30的队列
    pro_p = Process(target=producer,args=(q,))
    con_p = Process(target=consumer,args=(q,))
    pro_p.start()
    # 为了让消费者吃完包子就走人
    con_p.daemon = True
    con_p.start()
    # 这个join 是 process里面的join
    pro_p.join()
    print('主进程结束')

### 这两个join在两个模块里,功能不一样

　　　进程id,进程名字,查看进程是否活着is_alive()  terminate()发送结束进程的信号