内容概要

• 进程对象及其他方法
• 僵尸进程与孤儿进程
• 守护进程
• 互斥锁
• 队列介绍
• 进程间通信IPC机制
• 生产者消费者模型
• 线程相关知识点

进程对象及其他方法

如何查看进程的PID号
命令法:
windows: tasklist
         tasklist |findstr PID查看具体的进程
mac:     进入终端之后输入ps aux
	     ps aux|grep PID查看具体的进程

用python功能查看:

from multiprocessing import Process,current_process
    pid = current_process().pid  # 查看当前进程的进程号
    p.terminate()   # 杀死当前进程,是告诉操作系统帮你去杀死当前进程 但是需要一定的时间 而代码的运行速度极快
    p.is_alive()     # 判断当前进程是否存活
    
    用OS模块的功能查看:
    import os
    os.getpid()  # 查看当前进程进程号
    os.getppid()  # 查看当前进程的父进程进程号

代码实现:

from multiprocessing import Process,current_process
import os
import time


def task(name):
    print(f‘子进程{name}开始‘)
    # pid_1 = current_process().pid
    pid_1 = os.getpid()
    pid_2 = os.getppid()
    print(pid_1)
    print(pid_2)
    print(f‘子进程运行{name}结束‘)


if __name__ == ‘__main__‘:
    # pid = current_process().pid
    pid = os.getpid()
    print(pid,‘主‘)
    p = Process(target=task, args=(‘1‘,))
    p.start()
    time.sleep(3)   #  不能刚运行就杀死该程序
    p.terminate()
    time.sleep(2)
    print(p.is_alive())

僵尸进程与孤儿进程

# 僵尸进程
"""
死了但是没有死透
当你开设了子进程之后 该进程死后不会立刻释放占用的进程号
因为子进程要让父进程能够查看到它开设的子进程的一些基本信息 占用的pid号 运行时间
父进程会回收子进程占用的pid号等,父进程调用join方法等待子进程运行结束
所有的进程都会步入僵尸进程
	危险的僵尸进程: 父进程不死并且在无限制的创建子进程并且子进程也不结束
	
"""

# 孤儿进程
"""
子进程存活，父进程意外死亡
操作系统会开设一个“儿童福利院”专门管理孤儿进程回收相关资源
"""

守护进程

该子进程与主进程同生死,只要主进程结束,该守护进程一定会立即终止

方法:
p.daemon = True
注意: 将进程p设置成守护进程  这一句一定要放在start方法上面才有效否则会直接报错

互斥锁

多个进程操作同一份数据的时候，会出现数据错乱的问题
针对上述问题，解决方式就是加锁处理:将并发变成串行，牺牲效率但是保证了数据的安全

用法:
调用锁类生成互斥对象
mutex = Lock()

获得该互斥对象
mutex.accquire()

释放该互斥对象
mutex.release()

扩展: 行锁 表锁

注意：
1.锁不能轻易的使用，容易造成死锁现象(我们写代码一般不会用到，都是内部封装好的)
2.锁只在处理数据的部分加来保证数据安全(只在争抢数据的环节加锁处理即可)

代码实现:

def run(i, mutex):
    search(i)
    # 给买票环节加锁处理
    # 抢锁
    mutex.acquire()

    buy(i) # 操作数据
    # 释放锁
    mutex.release()


if __name__ == ‘__main__‘:
    # 在主进程中生成一把锁 让所有的子进程抢 谁先抢到谁先买票
    mutex = Lock()
    for i in range(1,11):
        p = Process(target=run, args=(i, mutex))
        p.start()

队列介绍

队列:管道+锁

管道:subprocess
stdin stdout stderr

队列:先进先出
堆栈:先进后出

使用方法:

from multiprocessing import Queue
# 创建一个队列
q = Queue  # 括号内可以传数字 标示生成的队列最大可以同时存放的数据量
# 往队列中存数据,当队列数据放满了之后 如果还有数据要放程序会阻塞 直到有位置让出来 不会报错
q.put(‘传的值‘)
# 去队列中取数据,队列中如果已经没有数据的话 get方法也会原地等待(阻塞)直到有数据为止
v = q.get()
v = q.get_nowait()  # 没有数据直接报错,信息为:queue.Empty
v = q.get(timeout=3)  # 没有数据之后原地等待三秒之后再报错,信息为:  queue.Empty
其他方法:
q.full()  # 判断当前队列是否满了
q.empty()  # 判断当前队列是否空了
"""
q.full()
q.empty()
q.get_nowait()
在多进程的情况下是不精确,因为下一瞬间队列可能被其他进程操作了
"""

代码实现:

from multiprocessing import Queue
q = Queue(3)
q.put(1)
q.put(2)
q.put(3)
try:
    print(q.full())
    v_1 = q.get()
    print(v_1)
    v_2 = q.get()
    print(v_2)
    v_3 = q.get()
    print(v_3)
    print(q.empty())
    v_4 = q.get(timeout=3)
    print(v_4)
except Exception as e:
    print(‘没有数据了‘)

IPC机制

进程间通信或者跨进程通信，是指两个进程之间进行数据交换的过程。
这里借助队列通信
使用方法:
同上

代码实现:

from multiprocessing import Queue,Process


def producer(q):
    q.put(‘hello‘)


if __name__ == ‘__main__‘:
    q = Queue()
    p = Process(target=(producer), args=(q,))
    p.start()
    res = q.get()
    print(res)

生产者消费者模型

生产者:生产/制造东西的
消费者:消费/处理东西的
该模型除了上述两个之外还需要一个媒介就是 队列

核心思想:
调用JoinableQueue模块用来计数,将消费者设置成守护进程,当q.join()运行时代表队列的数据已全部被消化,此时关闭主进程.
该模块功能:每当你往该队列中存入数据的时候 内部会有一个计数器+1,当你调用task_done的时候 计数器-1
q.join() 当计数器为0的时候 才往后运行

代码实现:

from multiprocessing import JoinableQueue,Process
import random
import time


def producer(x,porducer_name,q,name):
    for i in range(x):

        time.sleep(random.randint(1,3))
        q.put(name)
        print(f‘{porducer_name}产生数据{name}‘)

def consumer(q,teacher_name):
    while True:
        time.sleep(random.randint(1,3))
        name=q.get()
        if name:
            print(f‘{teacher_name}处理数据{name}‘)
            q.task_done()




if __name__ == ‘__main__‘:
    q = JoinableQueue()
    p2 = Process(target=producer,args=(4,‘egon‘,q,‘date‘))
    p3 = Process(target=producer,args=(4,‘tank‘,q,‘数据‘))
    p1 = Process(target=consumer, args=(q,‘json‘))
    p4 = Process(target=consumer, args=(q,‘lili‘))

    p2.start()
    p3.start()
    p1.daemon = True
    p4.daemon = True
    p4.start()
    p1.start()
    p2.join() # 如果不等这两个产生者,此时队列里没有数据,守护进程直接被干死了
    p3.join() # 如果不等这两个产生者,此时队列里没有数据,守护进程直接被干死了
    q.join()