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=, address='8C-16-45-92-1A-5B', netmask=None, broadcast=None, ptp=None), )}
网络交互信息，接口状态： {'以太网': snicstats(isup=False, duplex=, 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()