Python进程使用的内存总数?

是否有一种方法可以让Python程序确定它当前使用了多少内存?我看到过关于单个对象的内存使用情况的讨论，但我需要的是进程的总内存使用情况，这样我就可以确定何时需要开始丢弃缓存的数据。

376667 次浏览
小开

在unix上，你可以使用ps工具来监视它:

$ ps u -p 1347 | awk '{sum=sum+$6}; END {print sum/1024}'

其中1347是某个进程id。同样，结果的单位是MB。

小开

在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烹饪书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\n ...'
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
小开

对于基于Unix的系统(Linux, Mac OS X, Solaris)，您可以使用标准库模块resource中的getrusage()函数。结果对象具有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文件，还有这文件。

小开

使用sh和os进入python拜耳的答案。

float(sh.awk(sh.ps('u','-p',os.getpid()),'{sum=sum+$6}; END {print sum/1024}'))

答案是以兆字节为单位。

小开
最佳答案

在这里是一个有用的解决方案，适用于各种操作系统，包括Linux, Windows等:

import os, psutil
process = psutil.Process(os.getpid())
print(process.memory_info().rss)  # in bytes

注:

  • do 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发生了变化)。

小开 
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'])
小开

我喜欢它，谢谢@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上的当前内存使用情况，对于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('\n')[0][:-3]


return int(memusage.strip())
它读取当前进程的状态文件，取VmRSS:之后的所有内容，然后取第一个换行符之前的所有内容(隔离VmRSS的值)，最后切掉最后3个字节，这是一个空格和单位(kB)。
若要返回，则删除任何空白并将其作为数字返回

在Linux 4.4和4.9上测试，但即使是早期的Linux版本也可以工作:在man proc中查找/proc/$PID/status文件中的信息，它提到了某些字段的最低版本(例如Linux 2.6.10中的"VmPTE")，但是"VmRSS"field(我在这里使用)没有这样的提及。因此，我认为它已经在那里的早期版本。

小开

下面是我的函数装饰器，它可以跟踪这个进程在函数调用之前消耗了多少内存，在函数调用之后使用了多少内存，以及函数执行了多长时间。

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
小开

对于Python 3.6和psutil 5.4.5，更容易使用列出在这里的memory_percent()函数。

import os
import psutil
process = psutil.Process(os.getpid())
print(process.memory_percent())
小开

甚至比/proc/self/status: /proc/self/statm更容易使用。它只是一个由几个统计数据组成的空格分隔列表。我无法判断这两个文件是否始终存在。

/proc/[pid) / statm

提供内存使用情况的信息，以页为单位。 列为:

  • size(1)总程序大小 (与/proc/[pid]/status中的VmSize相同)
  • resident (2) resident集大小 (与/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次10万字节后，它增加了大约30万字节。

小开

对于Unix系统，如果您传递-v，命令time (/usr/bin/time)将提供该信息。参见下面的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

提交答案