【进程相关知识】

AMr.Yang

已于 2024-05-30 16:59:58 修改

阅读量146

点赞数 6

文章标签： python

于 2024-05-29 17:00:21 首次发布

本文链接：https://blog.csdn.net/weixin_49736094/article/details/139300520

版权

今日内容概要

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

今日内容详细

进程对象及其他方法

"""
一台计算机上运行着很多进程，那么计算机是如何区分并管理这些进程服务端的呢？
计算机会给每一个运行的进程分配一个PID号
如何查看
	Windows电脑 进入cmd输入tasklist查看
	tasklist |findstr PID查看具体的进程
	amc电脑包  ps aux
"""
from multiprocessing import Process, current_process
current_process().pid  # 查看当前进程的进程号

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

p = Process(target=task)
p.terminate() # 杀死当前进程
# 是告诉操作系统帮我杀死当前进程 但是需要一定的时间 而代码运行的速度极其的快
print(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=('egon',))
    p.daemon = True  # 将进程P设置为守护进程 这一句一定要放在start方法前面，不然会直接报错
    p.start()
    print('皇帝寿终正寝')

互斥锁

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

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

import random
from multiprocessing import Process, Lock
import json


# 查票
def search(i):
    # 文件操作读取票数
    with open('data', 'r', encoding='utf-8') as f:
        dic = json.load(f)
    print('用户%s查询余票：%s' % (i, dic.get('ticket_num')))


# 买票 1.查票 3.再买
def buy(i):
    # 先查票
    with open('data', 'r', encoding='utf-8') 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='utf-8') as f:
            json.dump(dic, f)
        print('用户%s买票成功' % i)
    else:
        print('用户%s买票失败' % i)
    pass


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


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

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

进程间通信

队列Queue模块

"""
管道：subprocess
队列：先进先出
堆栈：先进后出
"""

import queue

# 创建一个队列
q = queue.Queue(5)  # 括号内可以传数字 表示生成的队列最大可以同时存放的数据量

# 往队列中存数据
q.put(111)
q.put(222)
q.put(333)
# print(q.full())  # 判断当前队列是否满了
# print(q.empty()) # 判断队列是否空了
q.put(444)
q.put(555)
# print(q.full())
# q.put(666)  # 当队列数据放满了之后  如果还有数据程序会阻塞 直到有位置

"""
存取数据 存是为了更好的取
千方百计的存 简单快捷的取
"""

# 去队列中取数据
v1 = q.get()
v2 = q.get()
v3 = q.get()
v4 = q.get()
v5 = q.get()

try:
    v6 = q.get(timeout=3)
except Exception as e:
    print('没有了')
# v6 = q.get_nowait()  # 没有数据直接报错 queue.Empty
# v6 = q.get(timeout=3) # 没有数据会原地等待3秒再报错 queue.Empty
# v6 = q.get()  # 队列中如果已经没有数据的话，get方法会原地阻塞

# print(v1, v2, v3, v4, v5, v6)
"""
q.full()
q.empty()
q.get_nowait()
这些在多进程的情况下不能使用
"""

IPC机制

from multiprocessing import Process, Queue

"""
研究思路
    1.主进程跟子进程借助于队列通信
    2.子进程跟子进程借助于队列通信
"""


def producer(q):
    q.put('1号技师为你服务')
    # print('hello big baby~')


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


if __name__ == '__main__':
    q = Queue()
    p = Process(target=producer, args=(q,))
    p1 = Process(target=consumer, args=(q,))
    p.start()
    p1.start()
    # print(q.get())  # 不需要p.join() 队列的原则就是没有数据 原地等待

生产者消费者模型

"""
生产者:生产/制造东西的
消费者:消费/处理东西的
该模型除了上述两个东西外还需要一个媒介
	生活中的例子做包子的将包子做好后放在蒸笼里面，买包子的去蒸笼里面拿
	厨师做菜做完之后用盘子装着给消费者端过去
	生产者和消费者之间不是直接做交互的，而是借助于媒介做交互
	
生产者（做包子的） + 消息队列（蒸笼） + 消费者（吃包子的）
"""

from multiprocessing import Process, Queue, JoinableQueue
import time
import random

# 生产者
def producer(name, foo, q):
    for i in range(1, 5):
        data = '%s生产了%s %s' % (name, foo, i)
        # 模拟延迟
        time.sleep(random.randint(1, 3))
        print(data)
        # 将数据放入 队列中
        q.put(data)

# 消费者
def consumer(name, q):
    # 消费者胃口大 光盘行动
    while True:
        foo = q.get()
        # 判断当前是否有结束标识
        # if foo is None: break
        time.sleep(random.randint(1, 3))
        print('%s吃了%s' % (name, foo))
        q.task_done()  # 告诉队列你已经从里面取出了一个数据并处理完毕！


if __name__ == '__main__':
    q = JoinableQueue()
    p1 = Process(target=producer, args=('egon', '包子', q))
    p2 = Process(target=producer, args=('tank', '花卷', q))
    c1 = Process(target=consumer, args=('春哥', q))
    c2 = Process(target=consumer, args=('小明', q))

    p1.start()
    p2.start()

    # 给消费者设置成守护进程
    c1.daemon = True
    c2.daemon = True
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    # 等待生产者生产完毕之后 往队列中添加特定的结束符号
    # q.put(None)
    # q.put(None)
    q.join()  # 等待队里中所有的数据取完再往下执行代码

    """
    JoinableQueue 每当你往队列中存入数据的时候 内部会有一个计数器+1
    每当调用task_done的时候 计数器-1
    q.join() 当计数器为0的时候 才往下走
    """
    print('q.join()执行完执行的')
    # 只要q.join执行完毕，说明消费者已经处理完数据了  消费者就没有存在的必要了

线程理论

致命三问

什么是线程

"""
进程：资源单位
线程：执行单位 正在干活的人

将操作系统比喻成一个大的工厂，那么进程就相当于工厂里面的车间
而线程就是车间里面的流水线

每一个进程自带一个线程

再次总结：
	进程：资源单位（起一个进程仅仅只是在内存空间开辟一块独立的空间）
	线程：执行单位（真正被cpu执行的其实是进程里面的线程，线程指的就是代码的执行过程
	，执行代码中所需要使用到的资源都找所在的进程索要）
	
进程和线程都是虚拟单位，只是为了我们更加方便的描述问题
"""

为何要有线程

"""
开设进程
	1.申请内存空间 耗资源
	2.“拷贝代码”  耗资源
开线程
	一个进程内可以开设多个线程，在同一个线程内开设多个线程无需再次申请内存空间的操作
	
总结：
	1.开设线程的开销远远的小于进程的开销
	2.同一个进程下的多个线程数据是共享的
"""

如何使用