Python 进程使用的总内存是多少？
- 2024-12-11 08:48:00
- admin 原创
- 173
问题描述：
Python 程序是否有办法确定当前使用了多少内存？我见过关于单个对象的内存使用情况的讨论，但我需要的是该进程的总内存使用情况，以便我可以确定何时需要开始丢弃缓存数据。
解决方案 1：
这是一个适用于各种操作系统（包括 Linux、Windows 等）的有用解决方案：
import psutil
process = psutil.Process()
print(process.memory_info().rss) # in bytes
笔记：
pip install psutil如果尚未安装则执行如果你想快速知道你的进程占用了多少 MiB，这里有一个方便的一行代码：
import os, psutil; print(psutil.Process(os.getpid()).memory_info().rss / 1024 ** 2)
使用 Python 2.7 和 psutil 5.6.3 时，
process.memory_info()[0]情况就不同了（后来 API 发生了变化）。
解决方案 2：
对于基于 Unix 的系统（Linux、Mac OS X、Solaris），可以使用getrusage()标准库模块中的函数resource。生成的对象具有属性ru_maxrss，它给出了调用进程的峰值内存使用情况：
>>> resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
2656 # peak memory usage (kilobytes on Linux, bytes on OS X)
Python文档未注明单位。请参阅特定系统的man getrusage.2页面以检查值的单位。在 Ubuntu 18.04 上，单位为千字节。在 Mac OS X 上，单位为字节。
该getrusage()函数还可以resource.RUSAGE_CHILDREN用于获取子进程的使用情况，以及（在某些系统上）resource.RUSAGE_BOTH获取总（自身和子）进程的使用情况。
如果您只关心 Linux，您也可以选择阅读/proc/self/status或/proc/self/statm文件，如该问题的其他答案以及这个问题中所述。
解决方案 3：
在 Windows 上，您可以使用 WMI（主页、cheeseshop）：
def memory():
import os
from wmi import WMI
w = WMI('.')
result = w.query("SELECT WorkingSet FROM Win32_PerfRawData_PerfProc_Process WHERE IDProcess=%d" % os.getpid())
return int(result[0].WorkingSet)
在Linux上（来自python cookbook http://code.activestate.com/recipes/286222/：
import os
_proc_status = '/proc/%d/status' % os.getpid()
_scale = {'kB': 1024.0, 'mB': 1024.0*1024.0, 'KB': 1024.0, 'MB': 1024.0*1024.0}
def _VmB(VmKey):
'''Private.'''
global _proc_status, _scale
# get pseudo file /proc/<pid>/status
try:
t = open(_proc_status)
v = t.read()
t.close()
except:
return 0.0 # non-Linux?
# get VmKey line e.g. 'VmRSS: 9999 kB
...'
i = v.index(VmKey)
v = v[i:].split(None, 3) # whitespace
if len(v) < 3:
return 0.0 # invalid format?
# convert Vm value to bytes
return float(v[1]) * _scale[v[2]]
def memory(since=0.0):
'''Return memory usage in bytes.'''
return _VmB('VmSize:') - since
def resident(since=0.0):
'''Return resident memory usage in bytes.'''
return _VmB('VmRSS:') - since
def stacksize(since=0.0):
'''Return stack size in bytes.'''
return _VmB('VmStk:') - since
解决方案 4：
在unix上，可以使用该ps工具来监视它：
$ ps u -p 1347 | awk '{sum=sum+$6}; END {print sum/1024}'
其中 1347 是某个进程 ID。此外，结果以 MB 为单位。
解决方案 5：
Linux 上当前进程的当前内存使用情况（适用于 Python 2、Python 3和pypy），无需任何导入：
def getCurrentMemoryUsage():
''' Memory usage in kB '''
with open('/proc/self/status') as f:
memusage = f.read().split('VmRSS:')[1].split('
')[0][:-3]
return int(memusage.strip())
它读取当前进程的状态文件，获取 之后的所有内容VmRSS:，然后获取第一个换行符之前的所有内容（隔离 VmRSS 的值），最后截断最后 3 个字节，即空格和单位（kB）。
返回时，它会删除所有空格并将其作为数字返回。
在 Linux 4.4 和 4.9 上进行了测试，但即使是早期的 Linux 版本也应该可以工作：查看man proc并搜索/proc/$PID/status文件上的信息，它提到了某些字段的最低版本（例如“VmPTE”的最低版本是 Linux 2.6.10），但“VmRSS”字段（我在这里使用）没有这样的提及。因此，我假设它从早期版本开始就存在了。
解决方案 6：
下面是我的函数装饰器，它可以跟踪该过程在函数调用之前消耗了多少内存、在函数调用之后使用了多少内存以及该函数执行了多长时间。
import time
import os
import psutil
def elapsed_since(start):
return time.strftime("%H:%M:%S", time.gmtime(time.time() - start))
def get_process_memory():
process = psutil.Process(os.getpid())
return process.memory_info().rss
def track(func):
def wrapper(*args, **kwargs):
mem_before = get_process_memory()
start = time.time()
result = func(*args, **kwargs)
elapsed_time = elapsed_since(start)
mem_after = get_process_memory()
print("{}: memory before: {:,}, after: {:,}, consumed: {:,}; exec time: {}".format(
func.__name__,
mem_before, mem_after, mem_after - mem_before,
elapsed_time))
return result
return wrapper
所以，当你用它装饰一些函数时
from utils import track
@track
def list_create(n):
print("inside list create")
return [1] * n
您将能够看到以下输出：
inside list create
list_create: memory before: 45,928,448, after: 46,211,072, consumed: 282,624; exec time: 00:00:00
解决方案 7：
甚至比 更易于使用/proc/self/status： 。它只是几个统计数据/proc/self/statm的空格分隔列表。我无法判断这两个文件是否始终存在。
/proc/[pid]/statm
提供有关内存使用情况的信息（以页为单位）。列包括：
size (1) 程序总大小（与 /proc/[pid]/status 中的 VmSize 相同）
resident （2）驻留集大小（与 /proc/[pid]/status 中的 VmRSS 相同）
shared (3) 常驻共享页面的数量（即由文件支持）（与 /proc/[pid]/status 中的 RssFile+RssShmem 相同）
文本 (4) 文本（代码）
lib (5) 库（自 Linux 2.6 起未使用；始终为 0）
数据（6）数据+堆栈
dt（7）脏页（自 Linux 2.6 起未使用；始终为 0）
这是一个简单的例子：
from pathlib import Path
from resource import getpagesize
PAGESIZE = getpagesize()
PATH = Path('/proc/self/statm')
def get_resident_set_size() -> int:
"""Return the current resident set size in bytes."""
# statm columns are: size resident shared text lib data dt
statm = PATH.read_text()
fields = statm.split()
return int(fields[1]) * PAGESIZE
data = []
start_memory = get_resident_set_size()
for _ in range(10):
data.append('X' * 100000)
print(get_resident_set_size() - start_memory)
这将生成如下列表：
0
0
368640
368640
368640
638976
638976
909312
909312
909312
您可以看到，在大约 3 次 100,000 字节的分配之后，它会跳跃约 300,000 字节。
解决方案 8：
对于 Python 3.6 和 psutil 5.4.5，使用此处memory_percent()列出的函数更容易。
import os
import psutil
process = psutil.Process(os.getpid())
print(process.memory_percent())
解决方案 9：
我喜欢它，感谢@bayer。现在我得到了一个特定的进程计数工具。
# Megabyte.
$ ps aux | grep python | awk '{sum=sum+$6}; END {print sum/1024 " MB"}'
87.9492 MB
# Byte.
$ ps aux | grep python | awk '{sum=sum+$6}; END {print sum " KB"}'
90064 KB
附上我的进程列表。
$ ps aux | grep python
root 943 0.0 0.1 53252 9524 ? Ss Aug19 52:01 /usr/bin/python /usr/local/bin/beaver -c /etc/beaver/beaver.conf -l /var/log/beaver.log -P /var/run/beaver.pid
root 950 0.6 0.4 299680 34220 ? Sl Aug19 568:52 /usr/bin/python /usr/local/bin/beaver -c /etc/beaver/beaver.conf -l /var/log/beaver.log -P /var/run/beaver.pid
root 3803 0.2 0.4 315692 36576 ? S 12:43 0:54 /usr/bin/python /usr/local/bin/beaver -c /etc/beaver/beaver.conf -l /var/log/beaver.log -P /var/run/beaver.pid
jonny 23325 0.0 0.1 47460 9076 pts/0 S+ 17:40 0:00 python
jonny 24651 0.0 0.0 13076 924 pts/4 S+ 18:06 0:00 grep python
参考
内存 - Linux：找出哪个进程正在使用所有 RAM？ - 超级用户
Python 进程使用的总内存？ - 代码日志
linux - ps aux 输出含义
解决方案 10：
import os, win32api, win32con, win32process
han = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION|win32con.PROCESS_VM_READ, 0, os.getpid())
process_memory = int(win32process.GetProcessMemoryInfo(han)['WorkingSetSize'])
解决方案 11：
对于 Unix 系统命令time(/usr/bin/time)，如果您传递 -v，则会为您提供该信息。请参见Maximum resident set size下文，这是程序执行期间使用的最大（峰值）实际（非虚拟）内存：
$ /usr/bin/time -v ls /
Command being timed: "ls /"
User time (seconds): 0.00
System time (seconds): 0.01
Percent of CPU this job got: 250%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.00
Average shared text size (kbytes): 0
Average unshared data size (kbytes): 0
Average stack size (kbytes): 0
Average total size (kbytes): 0
Maximum resident set size (kbytes): 0
Average resident set size (kbytes): 0
Major (requiring I/O) page faults: 0
Minor (reclaiming a frame) page faults: 315
Voluntary context switches: 2
Involuntary context switches: 0
Swaps: 0
File system inputs: 0
File system outputs: 0
Socket messages sent: 0
Socket messages received: 0
Signals delivered: 0
Page size (bytes): 4096
Exit status: 0
解决方案 12：
使用 sh 和 os 进入 python bayer 的答案。
float(sh.awk(sh.ps('u','-p',os.getpid()),'{sum=sum+$6}; END {print sum/1024}'))
答案以兆字节为单位。
