cmd查看某一个进程是否正在运行_年薪百万之路--第三十五天 进程(下)

进程对象及其他方法

"""
一台计算机上面运行着很多进程,那么计算机是如何分区并管理这些进程服务端的呢?
计算机会给每一个运行的进程分配一个PID号
如何查看
windows: 进入cmd输入tasklist
         tasklist|findstr PID查看具体的进程
"""
from multiprocessing import Process,current_prcoess
courrent_prcoess().pid  #查看当前进程的进程号

import os
os.getpid() #查看当前进程进程号
os.getppid()  #查看当前进程的父进程进程号

p.terminate() #杀死当前进程(需要一定时间)
p.is_alive()  #判断当前进程是否存活

僵尸进程与孤儿进程(了解)

"""
僵尸进程:已经结束但没有彻底结束,当你开设了子进程之后,该进程结束后不会立即释放占用的进程号
因为要让父进程能够查看它所开设的子进程的一些基本信息(占用的PID号,运行时间)
所有的进程都会步入僵尸进程
如何回收子进程占用的PID号:
符进程等待子进程运行结束
父进程调用join方法
"""
孤儿进程
子进程存活,父进程结束
操作系统会有一个专门的机制回收相关资源
"""

守护进程

from multiprocessing import Process
import time


def task(name):
    print('%s守护正在活着'% name)
    time.sleep(3)
    print('%s守护正在死亡' % name)


if __name__ == '__main__':
    p = Process(target=task,args=('li',))
    p.daemon = True  # 将进程p设置成守护进程  这一句一定要放在start方法上面才有效否则会直接报错
    p.start()
    print('主结束')

互斥锁

多个进程操作同一份数据的时候,会出现数据错乱的问题

针对上述问题,解决方式就是加锁处理: 将并发变成串行,牺牲效率但是保证了数据安全

#模拟抢票
from multiprocessing import Process, Lock
import json
import time
import random


# 查票
def search(i):
    # 文件操作读取票数
    with open('data','r',encoding='utf8') as f:
        dic = json.load(f)
    print('用户%s查询余票：%s'%(i, dic.get('ticket_num')))
    # 字典取值不要用[]的形式 推荐使用get  你写的代码打死都不能报错！！！


# 买票  1.先查 2.再买
def buy(i):
    # 先查票
    with open('data','r',encoding='utf8') as f:
        dic = json.load(f)
    # 模拟网络延迟
    time.sleep(random.randint(1,3))
    # 判断当前是否有票
    if dic.get('ticket_num') > 0:
        # 修改数据库 买票
        dic['ticket_num'] -= 1
        # 写入数据库
        with open('data','w',encoding='utf8') as f:
            json.dump(dic,f)
        print('用户%s买票成功'%i)
    else:
        print('用户%s买票失败'%i)


# 整合上面两个函数
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()

注意：

1.锁不要轻易的使用，容易造成死锁现象(我们写代码一般不会用到，都是内部封装好的)

2.锁只在处理数据的部分加来保证数据安全(只在争抢数据的环节加锁处理即可)

进程间通信

队列

创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。

主进程跟子进程借助于队列通信

子进程跟子进程借助于队列通信

q.get( [ block [ ,timeout ] ] ) 
返回q中的一个项目。如果q为空，此方法将阻塞，直到队列中有项目可用为止。

q.get_nowait( ) 不等待直接返回

q.put(item [, block [,timeout ] ] ) 
将item放入队列。如果队列已满，此方法将阻塞至有空间可用为止。block控制阻塞行为，默认为True。如果设置为False，将引发Queue.Empty异常

q.empty() 
如果调用此方法时 q为空，返回True。如果其他进程或线程正在往队列中添加项目，结果是不可靠的。也就是说，在返回和使用结果之间，队列中可能已经加入新的项目。

q.full() 
如果q已满，返回为True. 由于线程的存在，结果也可能是不可靠的

生产者消费者模型

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

为什么要使用生产者和消费者模式

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

基于队列实现生产者消费者模型

from multiprocessing import Process,Queue
import time,random,os
def producer(name,food,q):
    for i in range(10):
        data = f'{name}生产了{food}{i}'
        time.sleep(random.randint(1,3))
        print(data)
        q.put(data) #将数据放入队列
def consumer(name,q):
    while True:
        food = q.get()
        time.sleep(random.randint(1,3))
        print(f'{name}吃了{food}')

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target = producer,args = ('生产者1','食物',q,))
    c1 = Process(target = consumer,args = ('消费者',q))
    p1.start()
    c1.start()
    #p1.join()
    #q.put(None)
    print('主')

此时的问题是主进程永远不会结束，原因是：生产者p在生产完后就结束了，但是消费者c在取空了q之后，则一直处于死循环中且卡在q.get()这一步。

解决方式无非是让生产者在生产完毕后，往队列中再发一个结束信号，这样消费者在接收到结束信号后就可以break出死循环。

结束信号None，不一定要由生产者发，主进程里同样可以发，但主进程需要等生产者结束后才应该发送该信号

JoinableQueue([maxsize])

创建可连接的共享进程队列。这就像是一个Queue对象，但队列允许项目的使用者通知生产者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的

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