Python入门-多进程

1.获取本机CPU

# 早期的CPU是单核：实现多个程序并行，在某一时间点，其实只有一个进程
# 后来硬件多核CPU：多个进程是并行执行。

from multiprocessing import cpu_count

print("CPU内核数量：", cpu_count())
"""
生命周期为：
1.分配pcb
2.获得山下文资源，等待CPU
3.CPU已获得，开始执行
4.如遇到无法执行，进入阻塞状态
5.到达自然结束点或者意外终结，进入终止状态
"""

进程类

import multiprocessing
import time

class Mypro(multiprocessing.Process):
    def __init__(self, name, delay, count):
        super().__init__(name=name) # 同时使用父类和子类的初始化
        self.__delay = delay
        self.__count = count
    def run(self):
        for i in range(self.__count):
            print("{}=进程id为：{}， 进程名字为：{}".format(i,
                        multiprocessing.current_process().pid,
                        multiprocessing.current_process().name))
            time.sleep(1)  # 减慢代码执行速度
if __name__ == '__main__':
    for i in range(3):
        #创建进程对象
        pro = Mypro(name="类进程-{}".format(i),
                    delay=1,
                    count=10)
        pro.start() #进程启动

"""
0=进程id为：15200， 进程名字为：类进程-0
0=进程id为：1148， 进程名字为：类进程-1
0=进程id为：9608， 进程名字为：类进程-2
1=进程id为：15200， 进程名字为：类进程-0
1=进程id为：1148， 进程名字为：类进程-1
1=进程id为：9608， 进程名字为：类进程-2
2=进程id为：15200， 进程名字为：类进程-0
2=进程id为：1148， 进程名字为：类进程-1
2=进程id为：9608， 进程名字为：类进程-2
3=进程id为：15200， 进程名字为：类进程-0
3=进程id为：1148， 进程名字为：类进程-1
3=进程id为：9608， 进程名字为：类进程-2
"""

多进程

import multiprocessing
import time

def worker(count):  # 专门的处理函数
    for i in range(count):
        print("{}=进程id为：{}， 进程名字为：{}".format(i,
               multiprocessing.current_process().pid,
               multiprocessing.current_process().name))
        time.sleep(1)  #减慢代码执行速度
def main():
    print("主进程id为：{}， 进程名字为：{}".format(
                multiprocessing.current_process().pid,
                multiprocessing.current_process().name))
    time.sleep(1)
if __name__ == '__main__':
    print("==============主进程===============")
    main()
    print("==============子进程===============")

    for i in range(3):
        #开始创建进程对象
        pro = multiprocessing.Process(
            target=worker,
            args=(10,),
            name="测试进程{}：".format(i))
        pro.start()  # 执行进程启动

"""
python程序都是通过主进程开始的，而后通过Process定义的进程都属于子进程
==============主进程===============
主进程id为：10556， 进程名字为：MainProcess
==============子进程===============
0=进程id为：5704， 进程名字为：测试进程0：
0=进程id为：588， 进程名字为：测试进程1：
0=进程id为：5352， 进程名字为：测试进程2：
1=进程id为：5704， 进程名字为：测试进程0：
1=进程id为：588， 进程名字为：测试进程1：
1=进程id为：5352， 进程名字为：测试进程2：
2=进程id为：588， 进程名字为：测试进程1：
2=进程id为：5352， 进程名字为：测试进程2：
2=进程id为：5704， 进程名字为：测试进程0：
"""

进程控制

import multiprocessing as mp
import time

def send(msg):
    time.sleep(5)
    print("进程id：{}，进程名称：{}".format(
                mp.current_process().pid,
                mp.current_process().name)) #获取当前进程信息

def main1():
    pro = mp.Process(
        target=send,
        args=("www.baidu.com",),
        name="main1，子进程发送中"
    )
    pro.start()
    print("main1，主发送进程id：{}，发送进程名字：{}，信息已发送完毕！！！".format(
        mp.current_process().name,
        mp.current_process().pid
    )) # 主进程的信息，在子进程执行完毕后才会输出

def main2():
    pro = mp.Process(
        target=send,
        args=("www.baidu.com",),
        name="main2，子进程发送中"
    )
    pro.start()
    pro.join()# 子进程强制优先执行
    print("main2，主发送进程id：{}，发送进程名字：{}，信息已发送完毕！！！".format(
        mp.current_process().name,
        mp.current_process().pid
    )) # 主进程的信息，在子进程执行完毕后才会输出
if __name__ == '__main__':
    print("===========主进程优先演示==============")
    main1()
    print("===========强制优先子进程演示============")
    main2()

"""
===========主进程优先演示==============
main1，主发送进程id：MainProcess，发送进程名字：15652，信息已发送完毕！！！
===========强制优先子进程演示============
进程id：15152，进程名称：main2，子进程发送中进程id：7376，进程名称：main1，子进程发送中
main2，主发送进程id：MainProcess，发送进程名字：15652，信息已发送完毕！！！
"""

守护进程

# 守护进程，随主进程进行

import multiprocessing
import time

#创建守护进程
def status():
    item = 1
    while True:
        print("守护进程id：{}， 守护进程名字：{}======{}".format(
            multiprocessing.current_process().pid,
            multiprocessing.current_process().name,item
        ))
        item += 1
        time.sleep(1)
#工作进程函数
def worker():
    shouhu_pro = multiprocessing.Process(target=status, name="守护进程", daemon=True)
    shouhu_pro.start()
    for i in range(10):
        print("工作id：{}， 工作进程：{}".format(
            multiprocessing.current_process().pid,
            multiprocessing.current_process().name
        ))
        time.sleep(1)
if __name__ == '__main__':
    def main():
        work_pro = multiprocessing.Process(target=worker, name="工作进程")
        work_pro.start() #启动工作进程
    main()
"""
工作id：6000， 工作进程：工作进程
守护进程id：5248， 守护进程名字：守护进程======1
工作id：6000， 工作进程：工作进程
守护进程id：5248， 守护进程名字：守护进程======2
工作id：6000， 工作进程：工作进程
守护进程id：5248， 守护进程名字：守护进程======3
工作id：6000， 工作进程：工作进程
守护进程id：5248， 守护进程名字：守护进程======4
工作id：6000， 工作进程：工作进程
守护进程id：5248， 守护进程名字：守护进程======5
工作id：6000， 工作进程：工作进程
守护进程id：5248， 守护进程名字：守护进程======6
工作id：6000， 工作进程：工作进程
守护进程id：5248， 守护进程名字：守护进程======7
工作id：6000， 工作进程：工作进程
守护进程id：5248， 守护进程名字：守护进程======8
工作id：6000， 工作进程：工作进程
守护进程id：5248， 守护进程名字：守护进程======9
工作id：6000， 工作进程：工作进程
守护进程id：5248， 守护进程名字：守护进程======10
"""

fork创建子进程，Windows平台无法执行

import os
import multiprocessing as mp

#fork创建的子进程是，不能跨平台的
def child(): #子进程
    print("【child】父进程id：{} ，子进程id：{}".format(
        os.getppid(), os.getpid()))
if __name__ == '__main__':
    def main():
        print("【main】进程id：{}， 进程名称：{}".format(
            mp.current_process().pid, mp.current_process().name
        ))
        #创建子进程
        newpid = os.fork()
        print("新的fork，子进程id：", newpid)
        if newpid == 0:
            child()
        else:
            print("父进程执行中:", os.getpid())
    main()

psutil模块，跨平台模块

#psutil是进程管理的，第三方模块，可以跨平台使用
import time
import psutil

#获取进程信息
for i in psutil.process_iter():
    print("进程编号：{}， 进程名称：{}， 创建时间：{}".format(
        i.pid, i.name(), time.ctime( i.create_time())[11:20]
    ))

#关闭进程
for i in psutil.process_iter():
    if i.name() == "notepad.exe":
        i.terminate() #关闭进程

"""
进程编号：14460， 进程名称：SogouCloud.exe， 创建时间：20:35:46
进程编号：15124， 进程名称：chrome.exe， 创建时间：20:35:53
进程编号：15492， 进程名称：QQLiveService.exe， 创建时间：20:37:34
进程编号：16044， 进程名称：dllhost.exe， 创建时间：20:49:34
进程编号：16048， 进程名称：chrome.exe， 创建时间：21:53:06
进程编号：16076， 进程名称：Lenovo.Modern.ImController.PluginHost.Device.exe， 创建时间：20:37:41
进程编号：16252， 进程名称：chrome.exe， 创建时间：21:54:45
"""    

#获取CPU信息
print("获取CPU的数量：", psutil.cpu_count(logical=False))
print("获取CPU的逻辑数量：", psutil.cpu_count(logical=True))
print("用户CPU的使用时间：", psutil.cpu_times().user)
print("系统CPU的使用时间：", psutil.cpu_times().system)
print("CPU的空闲时间：", psutil.cpu_times().idle)
for i in range(10):
    print("cpu使用监控：", psutil.cpu_percent(interval=1,percpu=True))
"""
获取CPU的数量： 4
获取CPU的逻辑数量： 8
用户CPU的使用时间： 1650.5625
系统CPU的使用时间： 1302.109375
CPU的空闲时间： 44414.21875
cpu使用监控： [23.9, 12.3, 15.2, 9.1, 20.0, 7.6, 19.7, 7.7]
cpu使用监控： [10.6, 6.2, 7.6, 3.1, 6.2, 4.7, 4.7, 10.8]
cpu使用监控： [25.7, 9.2, 15.9, 6.2, 20.0, 10.8, 25.4, 13.6]
cpu使用监控： [23.9, 7.7, 19.4, 4.6, 12.3, 9.2, 22.4, 12.3]
cpu使用监控： [11.9, 3.1, 9.1, 1.5, 6.1, 4.6, 10.8, 10.6]
cpu使用监控： [22.1, 12.1, 16.4, 9.4, 9.4, 12.3, 15.2, 16.9]
cpu使用监控： [20.6, 7.8, 15.2, 7.7, 7.7, 3.1, 23.2, 13.4]
cpu使用监控： [28.6, 27.3, 22.7, 14.1, 23.4, 14.1, 47.0, 9.4]
cpu使用监控： [17.6, 4.6, 3.1, 3.1, 10.6, 7.7, 6.2, 7.7]
cpu使用监控： [21.4, 6.1, 9.2, 10.6, 9.1, 3.1, 10.4, 12.3]
"""

# 获取磁盘的使用情况
print("获取磁盘信息：", psutil.disk_partitions())
print("获取磁盘使用率：", psutil.disk_usage("c:"))
print("获取磁盘io使用率：", psutil.disk_io_counters())
"""
获取磁盘信息： [sdiskpart(device='C:\\', mountpoint='C:\\', fstype='NTFS', opts='rw,fixed', maxfile=255, maxpath=260), sdiskpart(device='D:\\', mountpoint='D:\\', fstype='NTFS', opts='rw,fixed', maxfile=255, maxpath=260), sdi]
获取磁盘使用率： sdiskusage(total=126696288256, used=89786765312, free=36909522944, percent=70.9)
获取磁盘io使用率： sdiskio(read_count=173668, write_count=113137, read_bytes=4293250560, write_bytes=2654279168, read_time=963, write_time=93)
"""

#获取网络信息
print("网络交互信息,数据统计：", psutil.net_io_counters())
print("网络交互信息，接口统计：", psutil.net_if_addrs())
print("网络交互信息，接口状态：", psutil.net_if_stats())
"""
网络交互信息,数据统计： snetio(bytes_sent=10740489, bytes_recv=254469269, packets_sent=67731, packets_recv=104577, errin=0, errout=0, dropin=0, dropout=0)
网络交互信息，接口统计： {'以太网': [snicaddr(family=<AddressFamily.AF_LINK: -1>, address='8C-16-45-92-1A-5B', netmask=None, broadcast=None, ptp=None), )}
网络交互信息，接口状态： {'以太网': snicstats(isup=False, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=0, mtu=1500), }
"""

进程池

# 把多个进程放在进程池中，进行统一管理，提高性能的复用性
import time
import multiprocessing as mp
def work(item):
    time.sleep(1)
    return "工作进程id：{}，进程名称：{}, item={}".format(
        mp.current_process().pid,
        mp.current_process().name,
        item
    )
if __name__ == '__main__':
    pool = mp.Pool(processes = 2)
    for i in range(10):
        res = pool.apply_async(func=work, args=(i,)) # 非阻塞形式执行进程获取结果
        print(res.get())
    pool.close()
    pool.join()