求助 Linux 真实内存占用过大, htop 命令无法展示占用的进程
· 43 天前 · 2211 次点击
Linux 60G 47G 用掉了,昨天用 HTOP 看以为是 Mysql 占用的 经指点发现不是,但是找不到究竟是谁用的,麻烦帮忙看看
21 回复 &| &直到
09:43:46 +08:00
& &43 天前
& &43 天前
你需要按内存占用排序：
ps -eo rss,pmem,pcpu,vsize,args |
sort -k 1 -r -n | less
& &43 天前 via iPhone
我记得绿色的是 availible 的吧？能贴一下 free 的结果么？
& &43 天前
cached
Mem:
-/+ buffers/cache:
& &43 天前
@ 我这个排过的 用你的命令排出来的进程顺序和图上是一致的
& &43 天前
确实不是某个进程导致的，是不是 tmpfs 使用过多？
& &43 天前
cat /proc/meminfo
& &43 天前
df -h
Filesystem
Used Avail Use% Mounted on
/dev/xvda1
63% /
devtmpfs
1% /dev
tmpfs
0% /dev/shm
/dev/xvdb1
感谢之意无以言表
& &43 天前
cat /proc/meminfo
MemTotal:
kB
MemFree:
2228000 kB
MemAvailable:
kB
Buffers:
327824 kB
Cached:
kB
SwapCached:
0 kB
Active:
8945140 kB
Inactive:
3568212 kB
Active(anon):
1801992 kB
Inactive(anon):
9432 kB
Active(file):
7143148 kB
Inactive(file):
3558780 kB
Unevictable:
0 kB
Mlocked:
0 kB
SwapTotal:
0 kB
SwapFree:
0 kB
Dirty:
76 kB
Writeback:
0 kB
AnonPages:
1801496 kB
Mapped:
52352 kB
Shmem:
9940 kB
Slab:
kB
SReclaimable:
kB
SUnreclaim:
68208 kB
KernelStack:
3376 kB
PageTables:
14700 kB
NFS_Unstable:
0 kB
Bounce:
0 kB
WritebackTmp:
0 kB
CommitLimit:
kB
Committed_AS:
3442324 kB
VmallocTotal:
kB
VmallocUsed:
0 kB
VmallocChunk:
0 kB
AnonHugePages:
26624 kB
HugePages_Total:
0
HugePages_Free:
0
HugePages_Rsvd:
0
HugePages_Surp:
0
Hugepagesize:
2048 kB
DirectMap4k:
12288 kB
DirectMap2M:
楼上 V 友帮忙找到问题了
应该是 tmpfs 的问题
& &43 天前 via Android
应该是 linux 的页高速缓存机制导致的这种现象。这种情况下好多物理页被标记为脏页，当剩余内存达到某个阈值的时候内核会将这些脏页的数据刷回磁盘，然后将这些脏页回收用以重新分配
& &43 天前
Google Slab 占用高。
& &43 天前
@ 感谢 获益匪浅
& &43 天前 via Android
Linux 的内存管理一直比较吭的
& &43 天前
Linux 的内存管理比 Windows 强太多，楼主不防试试 ZRAM，把交换分区放到内存
Windows 无论有多少内存，一开机就在硬盘上使劲读写交换文件，很影响性能
& &43 天前
正常过程是 系统先使用内存，内存不足了再使用，tmpfs 的。tmpfs 满了，系统内存再满了，你机器就挂了。
你看看系统内存什么情况吧。
如果系统内存正常，tmpfs 满了说明你服务有问题
& &43 天前
补充一点，肯定是哪个进程创建了过多的临时目录，或者对文件系统有过多的写入，导致写入到 tmpfs 这个拿物理内存当“虚拟硬盘用的 tmpfs ”占用物理内存过高。
& &43 天前
Slab +1，同被坑过
& &43 天前
可以用 atop 命令
& &42 天前
& &42 天前
问两个问题：
1、准确原因是什么？
2、怎么解决的。
我的机子可能也有这个问题，但还不确定。
& &42 天前
Slab dentry 过大导致的问题
没有解决 查资料说是到达阈值会自动清理的 现在服务器没有问题也就没有手动清理这个
& · & 2155 人在线 & 最高记录 3541 & · &
创意工作者们的社区
World is powered by solitude
VERSION: 3.9.8.0 · 20ms · UTC 14:35 · PVG 22:35 · LAX 07:35 · JFK 10:35? Do have faith in what you're doing.如何计算字符串在内存中占用的字节数_百度知道
如何计算字符串在内存中占用的字节数
我有更好的答案
trlen()函数.h&int main(){printf(&%d\return 0;}结果：5，也就是“1234\n&,strlen(&1234\n&))，返回字符串的字节数;stdio；例如#include&lt
strlen(char_str)*sizeof(char));就可以输出了，然后用长度乘以上面用sizeof函数算出来的字节数;这个函数，然后用strlen();函数计算字符串的长度（也就是字符串中包含多少个字符）;字符串在内存中所占用内存为%d&，你得知道一个字符型数据占内存的多少空间，然后直接用printf(&quot、假设你的字符串数组名为char_str，用sizeof()，最后就是字符串在内存中占用的字节数了、首先
本回答被网友采纳
为您推荐：
其他类似问题
字符串的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。为什么电脑内存占用量特别大_百度知道
为什么电脑内存占用量特别大
刚买没多久的新电脑 也没有开什么程序 但是内存一直有50%左右被占掉了我的内存是4G相当于有2G一直被用着 应该没有中毒不知道怎么回事 求高人指点
我有更好的答案
可能是电脑的内存本身不大、后台运行软件太多和病毒原因。解决方案如下：1、使用杀毒软件对电脑进行全盘杀毒。2、不要安装过多的杀毒软件或安全卫士之类的软件。3、 用360清理无用启动项、清理无用插件、清理垃圾。4、尽量把软件安装在非系统盘中。5、购买内存条。购买内存条注意事项1、了解电脑主板，查阅主板最高支持多大的内存，还有就是电脑拥有几个内存条插槽。有的只有一个插槽，而有的含有两个。2、了解你的电脑主板，查阅你的爱机主板最高支持多大的内存，还有就是你的爱机拥有几个内存条插槽。有的只有一个插槽，而有的含有两个。3、工作频率也是最重要的参数哟。一般的内存工作频率为1600MHZ和1333MHZ。在购买时一定要注意工作频率哟。4、如果了解的电脑可以增加内存，最安全的购买方式就是使用硬件检测工具，检测电脑原装的内存信息。购买与原装相同的内存条。这是最保险的，最安全的选购方式。
用360开机加速，上面三个标签页中能不启动的就禁止启动，重启后会腾出不少内存的
本回答被提问者和网友采纳
一般都都可以关，建议用360卫士优化加速这工具把没用的进程关掉，特别是一些自启动的
其实也不算是很多
可能你用了什么美化的软件之后就会出现这种情况
建议使用优化软件优化一下你的电脑
这样会好很多
闭多余的后台运用，关闭多余的开机启动程序，有些系统本来就比较干净，装好的开机气动就不多，我的系统开机加卡巴斯基和360才19个进程，你看看你开机有多少个进程，至于后台运用，可以在“管理工具”里面改，不会的话，装个优化大师，用优化大师改，比较方便。是不是品牌机啊？品牌机预装程序多，如果不是，开机34个进程估计是中毒了，总之你用下优化大师吧，里面有个进程管理，可以帮你看懂每个进程，有没有用，是不是病毒等等，当然要在可以上网的时候。还有，杀杀毒
建议你按下面操作1、卸载掉用不到的软件;2、用360、或电脑管家开机优化，关闭不需要的启动项。3、关闭系统的睡眠系统，从不睡眠（开始—》控制面板—》电源管理），睡眠文件会占用很大的空间。4、关闭自动更新，系统防火墙。（360、QQ电脑管家都可以胜任）5、一些没有必要的软件不必安装。6、其实杀毒软件不用一直开着，不用开机启动，占资源（360或QQ电脑管家已有监测的功能），用的时候启动就可以，平时不需要。
你系统中多余程序运行过多，可以选择修改启动项方法禁止一些诸如鲁大师、360硬件等，另外杀毒软件至需要一种，或者干脆卸载一些没用或者很少用到的程序，可以很好提高空闲内存！
其他4条回答
为您推荐：
其他类似问题
您可能关注的内容
电脑内存的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。精确计算一个Java对象占用的内存大小
《java优化占用内存的方法
--&雪的痕迹》一文中提到：
java做的系统给人的印象是什么？占内存！说道这句话就会有N多人站出来为java辩护，并举出一堆的性能测试报告来证明这一点。其实从理论上来讲java做的系统并不比其他语言开发出来的系统更占用内存，那么为什么却有这么N多理由来证明它确实占内存呢？两个字，"陋习"。
那如何衡量对象占用的内存空间大小呢？有人可能会说简单的使用如下代码：
Runtime.getRuntime().totalMemory() -
Runtime.getRuntime().freeMemory();
然而这样做只能计算出堆中所有实例占用的内存大小，无法做到对一个对象的精确计算，
本人写了一段小代码计算对象的内存占用量，得出的结果和自己的电脑上内存的使用量一样，电脑配置是64位CPU，装32位XP操作系统，32位sun的虚拟机(参数-client)，内存3G，不清楚程序是否通用。
算法简述：
1.值类型变量占用大小已知
2.引用类型变量占用大小4字节（还没有在64位JVM下测试过），如Object x =
&这个x变量在32位jvm中测得占用4字节
3.对象大小与占用空间的关系：occupy = (size + 8 - 1) / 8 *
4.递归的遍历一个对象内的所有成员变量，成员变量的成员变量的占用的内存大小，
(目前无法对包含private&java.lang.reflect.Constructot类型的成员的对象计算大小，因为无法通过反射获得对象该字段的值)。
import java.lang.reflect.*;
import java.util.*;
//一个引用：4字节
//一个Object：8字节
//一个Integer：16字节 == (8 + 4+8-1) /
//一个int：4字节
//长度为0的数组大小：JRo64=24,
//引用大小，如Object = null：
&JRo64=JRo32=4, Sun32=4,
//无成员的对象大小，如new Object();：
& & JRo32=JRo64=8, Sun32=8,
//new byte[0]: &
& &JRo32=JRo64=8+8 Sun32=8+4,
Sun64=16+8
//长度l的byte数组：(l+12+8-1)/8*8
//长度l的char/short数组：(l*2+12+8-1)/8*8 == (l+9)/4*8
//长度l的String：(l+1)/4*8+40
//长度l的int数组：(l*4+12+8-1)/8*8 ==(l+4)/2*8
//长度l的long数组：(l*8+12+8-1)/8*8 == (l+2)*8
public class Occupy {
&&//这8个方法不写不行，否则occupyof(int
x)会自动重载到occupyof(Object o),并且无法在方法中判断
&&public static int
occupyof(boolean variable) {
&& &return
&&public static int
occupyof(byte variable) {
&& &return
&&public static int
occupyof(short variable) {
&& &return
&&public static int
occupyof(char variable) {
&& &return
&&public static int
occupyof(int variable) {
&& &return
&&public static int
occupyof(float variable) {
&& &return
&&public static int
occupyof(long variable) {
&& &return
&&public static int
occupyof(double variable) {
&& &return
&&public Occupy(byte
nullReferenceSize, byte emptyObjectSize, byte emptyArrayVarSize)
&this.NULL_REFERENCE_SIZE = nullReferenceS
&this.EMPTY_OBJECT_SIZE = emptyObjectS
&this.EMPTY_ARRAY_VAR_SIZE =
emptyArrayVarS
&&public static Occupy
forJRockitVM() {
&& &return
new Occupy((byte) 4, (byte) 8, (byte) 8);
&&public static Occupy
forSun32BitsVM() {
&& &return
new Occupy((byte) 4, (byte) 8, (byte) 4);
&&public static Occupy
forSun64BitsVM() {
&& &return
new Occupy((byte) 8, (byte) 16, (byte) 8);
&&public static Occupy
forDetectedVM(){
&& &return
&&private final byte
NULL_REFERENCE_SIZE;
&&private final byte
EMPTY_OBJECT_SIZE;
&&private final byte
EMPTY_ARRAY_VAR_SIZE;
&&private static class
&& &public
ref(Object obj){
&this.obj =
&@Override
&& &public
boolean equals(Object obj) {
&return (obj instanceof ref)
&& ((ref)obj).obj == this.
&@Override
&& &public
int hashCode() {
&return obj.hashCode();
&&private List dedup = new
ArrayList();
&&public int occupyof(Object
&dedup.clear();
&& &return
occupyof0(object);
&&private int occupyof0(Object
(object == null)
&return 0;
&& &ref r =
new ref(object);
&if(dedup.contains(r))
&return 0;
&dedup.add(r);
varSize = 0;//对象中的值类型、引用类型变量大小
objSize = 0;//对象中的引用类型指向的对象实例的大小
(Class clazz = object.getClass(); clazz != Object. clazz =
clazz.getSuperclass()) {
&System.out.println(clazz);
&if (clazz.isArray()) {//当前对象的数组
& &varSize +=
EMPTY_ARRAY_VAR_SIZE;
componentType = clazz.getComponentType();
(componentType.isPrimitive()) {//当前数组是原生类型的数组
&varSize += lengthOfPrimitiveArray(object)
* sizeofPrimitiveClass(componentType);
&return occupyOfSize(EMPTY_OBJECT_SIZE,
varSize, 0);
& &Object[] array = (Object[])
& &varSize +=
NULL_REFERENCE_SIZE *
array.//当前数组有length个引用，每个占用4字节
& &for (Object o : array)
&objSize += occupyof0(o);
occupyOfSize(EMPTY_OBJECT_SIZE, varSize, objSize);
&Field[] fields = clazz.getDeclaredFields();
&for (Field field : fields) {
(Modifier.isStatic(field.getModifiers()))
&//类成员不计
&//System.out.println(field.getDeclaringClass());
& &if(clazz !=
field.getDeclaringClass())
&Class&?& type =
field.getType();
& &if (type.isPrimitive())
&varSize +=
sizeofPrimitiveClass(type);
&varSize +=
NULL_REFERENCE_SIZE;//一个引用型变量占用4个字节
& & &try {
&field.setAccessible(true);//可以访问非public类型的变量
& &objSize +=
occupyof0(field.get(object));
& & &} catch
(Exception e) {
&objSize += occupyofConstructor(object,
&return occupyOfSize(EMPTY_OBJECT_SIZE,
varSize, objSize);
&&public static int
sizeof(boolean variable) {
&& &return
&&public static int
sizeof(byte variable) {
&& &return
&&public static int
sizeof(short variable) {
&& &return
&&public static int
sizeof(char variable) {
&& &return
&&public static int sizeof(int
variable) {
&& &return
&&public static int
sizeof(float variable) {
&& &return
&&public static int
sizeof(long variable) {
&& &return
&&public static int
sizeof(double variable) {
&& &return
&&public int sizeof(Object
(object == null)
&return 0;
&int size =
EMPTY_OBJECT_SIZE;
clazz = object.getClass();
(clazz.isArray()) {
EMPTY_ARRAY_VAR_SIZE;//length变量是int型
componentType = clazz.getComponentType();
&if (componentType.isPrimitive())
& &return size +
lengthOfPrimitiveArray(object) *
sizeofPrimitiveClass(componentType);
&Object[] array = (Object[])
&size += 4 * array.
&for (Object o : array)
& &size +=
sizeof(o);
&& &Field[]
fields = clazz.getDeclaredFields();
(Field field : fields) {
&if (Modifier.isStatic(field.getModifiers()))
& &//类成员不计
&Class&?& type =
field.getType();
&if (type.isPrimitive())
& &size +=
sizeofPrimitiveClass(type);
& &size +=
4;//一个引用型变量占用4个字节
&field.setAccessible(true);//可以访问非public类型的变量
sizeof(field.get(object));
& &} catch (Exception e) {
& & &size +=
sizeofConstructor(object, field);
&& &return
&&private static int
occupyofConstructor(Object object, Field field) {
&& &throw new
UnsupportedOperationException("field type Constructor not
accessible: " + object.getClass() + " field:" + field);
&&private static int
sizeofConstructor(Object object, Field field) {
&& &throw new
UnsupportedOperationException("field type Constructor not
accessible: " + object.getClass() + " field:" + field);
&&private static int
occupyOfSize(int size) {
&return (size + 7) / 8 * 8;
&&private static int
occupyOfSize(int selfSize, int varsSize, int objsSize)
&System.out.println("self=" + selfSize + " vars="
+ varsSize + " objs=" + objsSize);
&return occupyOfSize(selfSize) +
occupyOfSize(varsSize) + objsS
&&private static int
sizeofPrimitiveClass(Class clazz) {
&& &return
clazz == boolean.class || clazz == byte.class ? 1 : clazz ==
char.class || clazz == short.class ? 2 : clazz == int.class ||
clazz == float.class ? 4
&&private static int
lengthOfPrimitiveArray(Object object) {
&Class&?& clazz =
object.getClass();
&& &return
clazz == boolean[].class ? ((boolean[]) object).length : clazz ==
byte[].class ? ((byte[]) object).length
& &: clazz == char[].class ?
((char[]) object).length : clazz == short[].class ? ((short[])
object).length
&: clazz == int[].class ? ((int[]) object).length
: clazz == float[].class ? ((float[]) object).length
& & &: clazz ==
long[].class ? ((long[]) object).length : ((double[])
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。