近期有网上朋友寻求帮助:如何通过脚本动态控制Linux系统的内存占用百分比?经过一番百度+编写调试,终于初步完成了动态控制Linux系统内存占用百分比。现写出来以帮助更多的朋友。
1 前言
根据需求是动态控制Linux系统内存占用百分比,比如当前内存占用30%,如果设置内存占用为70%,则需要申请内存使达到占用70%;如果再降低到40%,则需要释放部分申请的内存。其实脚本的本质是内存动态申请与释放。
注意:因为Python脚本运行之前内存有一定占用,故设定内存占用不能低于该百分比。
2 内存动态申请
通过查询资料,使用Python动态申请内存块,可以使用ctypes包中的函数,导入包及代码如下所示:
>>>from ctypes import *
>>>mem=create_string_buffer(1024)
说明:内存申请使用create_string_buffer()函数,上面申请了1024字节的内存块。
下面演示申请100MB内存前后变化
申请前如下图所示:
使用代码如下:
>>>mem=create_string_buffer(104857600)
申请后如下图所示:
从上述两幅图中可以看出,申请内存前内存占用295MB,申请后内存占用397MB,增加了约100MB内存占用。
3 内存动态释放
由于Python对内存是有垃圾回收机制的,采用对象引用计数方式。当对象的引用计数为0时,启动垃圾回收GC。此处内存动态释放就是使用该原理。
代码如下:
>>>mem=None
释放后内存占用如下图所示:
内存占用由397MB降低到297MB,释放了100MB内存占用。
说明:将None赋值给对象mem后,mem对象的引用计数即为0,此时垃圾回收启动,释放mem对象占用的内存。
4 系统总内存、占用内存检测
由于需要设定内存占用百分比,故需要获取系统总物理内存和占用内存。本文使用的方法是读取系统文件“/proc/meminfo”,从中解析出总内存大小以及当前内存占用大小等内存相关的信息。该文件内容格式如下图所示:
代码片段如下所示:
f = open("/proc/meminfo")
lines = f.readlines()
f.close()
for line in lines:
if len(line)<2:continue
name = line.split(':')[0]
var = line.split(':')[1].split()[0]
mem[name]= long(var)* 1024.0
mem['MemUsed']= mem['MemTotal']- mem['MemFree']
说明:按行读取meminfo文件内容,创建字典对象mem,将meminfo文件第一列设置为mem对象的键值,将meminfo文件第二列数字设置为mem对象的值。
5 获取用户输入百分比
通过读取键盘输入字符串,然后转换为数字实现接收用户输入的百分比,代码如下所示:
input_str=raw_input("Input UsedMemory`s Rate or q to exit:")
rate=float(input_str)
注意:此处键盘输入的都是字符串,需要进行字符串转换为数字,使用float()或long()函数进行转换。
6 动态设置内存占用百分比测试
测试使用两个Python脚本文件,分别是test.py和mem_rate.py,其功能分别是查看当前内存占用和动态设定内存占用百分比。如下图所示:
注意:上述两个文件需要使用“chmod +x *.py”修改为可执行属性。
6.1 查看当前内存占用
查看当前内存占用百分比,使用上述test.py文件,运行命令为“./test.py”,运行结果如下图所示:
当前使用内存为320MB,占用百分比为17%。
6.2 动态设置内存占用百分比
动态设置内存占用百分比使用上述mem_rate.py脚本,注意该脚本文件第一行代码为“#!/usr/bin/python2.6”,表示该脚本使用python2.6程序运行。该行需要修改为待运行Linux系统中Python实际的安装程序路径。
动态内存百分比设置界面如下图所示:
处于待输入状态。另外显示了当前内存占用(321MB),总内存大小(1869MB)以及内存占用百分比(17%)。
如果此时设置内存占用百分比为80%,则脚本会每次申请10MB空间,直至内存占用接近或等于80%为止。如下图所示:
内存申请过程如下图所示:
内存申请过程中占用百分比变化为:35%,45%,56%,70%,…
mem_rate.py运行过程如下图所示:
内存申请过程中占用变化为:1461MB,1471MB,1481MB,1491MB。
此时如果内存占用百分比设置为20%,则需要释放一部分内存。
test.py脚本运行过程如下图所示:
由于释放内存运行较快,抓取到最后结果
内存占用为20%。
mem_rate.py脚本运行过程如下图所示:
内存释放过程中内存占用为:413MB,403MB,393MB,383MB,最后内存占用稳定在20%,383MB。
输入“q”或“Q”退出内存占用百分比设定过程,如下图所示:
此时内存占用如下图所示:
内存占用恢复到运行mem_rate.py脚本之前状态,17%,321MB。
※※※※※※※※※※※※※※※※※※※※※※※※※※※※※
附:完整Python脚本代码
test.py
------------------------------------------------------------------------------------------------
#!/usr/bin/python2.6
def memory_stat():
mem = {}
f = open("/proc/meminfo")
lines = f.readlines()
f.close()
for line in lines:
if len(line)<2:continue
name = line.split(':')[0]
var = line.split(':')[1].split()[0]
mem[name]= long(var)* 1024.0
mem['MemUsed']= mem['MemTotal']- mem['MemFree']
# - mem['Buffers']- mem['Cached']
return mem
mem=memory_stat()
print("Used(MB):%d"%(long(mem['MemUsed'])/1024/1024))
print("Rate:%d%%"%(100*long(mem['MemUsed'])/float(mem['MemTotal'])))
§§§§§§§§§§§§§§§§§§§§§§§§§§
mem_rate.py
---------------------------------------------------
#!/usr/bin/python2.6
from ctypes import *
# Get Memory Info(Total, Used... Byte)
def get_memory_stat():
mem = {}
f = open("/proc/meminfo")
lines = f.readlines()
f.close()
for line in lines:
if len(line)<2:continue
name = line.split(':')[0]
var = line.split(':')[1].split()[0]
mem[name]= long(var)* 1024.0
mem['MemUsed']= mem['MemTotal']- mem['MemFree']
# Return MemroyInfo Object
return mem
# Get Simple Memory Info
def get_memory_info(mem):
# Byte ->MB
n=1024* 1024
used=float(mem['MemUsed'])/ n
total=float(mem['MemTotal'])/ n
rate=used/total* 100
smp={'used':used,'total':total,'rate':rate}
return smp
# Display Current Memory Info
def print_memory_info(mem):
# Get SimpleMemory Info
smp=get_memory_info(mem)
print("Used(MB):%d\tTotal(MB):%d\tUsedRate:%d%%"%(smp['used'], smp['total'], smp['rate']))
# Get Rate Of Memory Used To Be Setted(Integer Formate)
def input_memory_used_rate(org_rate):
# Byte ->MB
n=1024* 1024
while(True):
mem=get_memory_stat()
print_memory_info(mem)
input_str=raw_input("Input UsedMemory`s Rate or q to exit:")
if(len(input_str)== 0):
continue
if("q"== input_str):
info={'rate':0,'used':mem['MemUsed']/ n}
return info
if("Q"== input_str):
info={'rate':0,'used':mem['MemUsed']/ n}
return info
try:
rate=float(input_str)
if((rate>=org_rate)and (rate<=95)):
info={'rate':rate,'used':mem['MemUsed']/ n}
return info
else:
print("Please inputa valid number(%d%%~95%%)."%(org_rate))
except:
print("Please inputa valid number(%d%%~95%%)."%(org_rate))
# Set Rate Of Memory Used
def set_memory_used_rate(new_rate, total, pre_used,list):
if(new_rate==0):
return None
dest_mem=total* new_rate /100.0
# 10MB
mb10=10485760
n_chg=10
# Free Memory OrAllocate Memory ?
is_new=dest_mem>pre_used
cur_used=pre_used
while(True):
# To Calc FreeMemory Or Allocate Memory ?
need_new=dest_mem-n_chg>=pre_used
need_del=dest_mem+n_chg<=pre_used
# Need To AllocateMemory
if(is_new):
if(need_new):
p=create_string_buffer(mb10)
list.append(p)
dest_mem=dest_mem-n_chg
cur_used=cur_used+n_chg
else:
return"end"
# Need To FreeMemory
else:
idx=len(list)-1
if(need_deland (idx>=0)):
p=list[idx]
del list[idx]
p=None
dest_mem=dest_mem+n_chg
cur_used=cur_used-n_chg
else:
return"end"
print("****** MemoryUsed(MB):%d"%(cur_used))
# Entry Of Program
# List Of Memory Object, 10MB Of One Object
list=[]
# Get Current Memory Info
mem=get_memory_stat()
# Get Simple Memory Info
smp=get_memory_info(mem)
org_rate=smp['rate']
total=smp['total']
while(True):
# Get Rate OfMemory To Be Used
info=input_memory_used_rate(org_rate)
new_rate=float(info['rate'])
pre_used=float(info['used'])
# Set Rate OfMemory To Be Used
rtn=set_memory_used_rate(new_rate, total, pre_used, list)
if(not rtn):
print("bye!")
exit()
python控制内存的方法:一、对象的引用计数机制
二、垃圾回收机制
三、内存池机制
一、对象的引用计数机制
Python内部使用引用计数,来保持追踪内存中的对象,所有对象都有引用计数。
引用计数增加的情况:
1、一个对象分配一个新名称
2、将其放入一个容器中(如列表、元组或字典)
引用计数减少的情况:
1、使用del语句对对象别名显示的销毁
2、引用超出作用域或被重新赋值 sys.getrefcount( )函数可以获得对象的当前引用计数
多数情况下,引用计数比你猜测得要大得多。对于不可变数据(如数字和字符串),解释器会在程序的不同部分共享内存,以便节约内存。
二、垃圾回收
1、当一个对象的引用计数归零时,它将被垃圾收集机制处理掉。
2、当两个对象a和b相互引用时,del语句可以减少a和b的引用计数,并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用,因此引用计数不会归零,对象也不会销毁。(从而导致内存泄露)。为解决这一问题,解释器会定期执行一个循环检测器,搜索不可访问对象的循环并删除它们。
三、内存池机制
Python提供了对内存的垃圾收集机制,但是它将不用的内存放到内存池而不是返回给操作系统。
1、Pymalloc机制。为了加速Python的执行效率,Python引入了一个内存池机制,用于管理对小块内存的申请和释放。
2、Python中所有小于256个字节的对象都使用pymalloc实现的分配器,而大的对象则使用系统的malloc。
3、对于Python对象,如整数,浮点数和List,都有其独立的私有内存池,对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数,用于缓存这些整数的内存就不能再分配给浮点数。
更多Python知识请关注Python视频教程栏目。