JVM监控命令详解(转)
JVM监控命令基本就是 jps、jstack、jmap、jhat、jstat 几个命令的使用就可以了
JDK本身提供了很多方便的JVM性能调优监控工具，除了集成式的VisualVM和jConsole外，还有jps、jstack、jmap、jhat、jstat等小巧的工具，本博客希望能起抛砖引玉之用，让大家能开始对JVM性能调优的常用工具有所了解。
现实企业级Java开发中，有时候我们会碰到下面这些问题：
OutOfMemoryError，内存不足
内存泄露
线程死锁
锁争用（Lock Contention）
Java进程消耗CPU过高
......
这些问题在日常开发中可能被很多人忽视（比如有的人遇到上面的问题只是重启服务器或者调大内存，而不会深究问题根源），但能够理解并解决这些问题是Java程序员进阶的必备要求。本文将对一些常用的JVM性能调优监控工具进行介绍，希望能起抛砖引玉之用。本文参考了网上很多资料，难以一一列举，在此对这些资料的作者表示感谢！关于JVM性能调优相关的资料，请参考文末。
A、 jps(Java Virtual Machine Process Status Tool)
jps主要用来输出JVM中运行的进程状态信息。语法格式如下：
JVM监控命令详解(转)
JVM监控命令基本就是 jps、jstack、jmap、jhat、jstat 几个命令的使用就可以了
JDK本身提供了很多方便的JVM性能调优监控工具，除了集成式的VisualVM和jConsole外，还有jps、jstack、jmap、jhat、jstat等小巧的工具，本博客希望能起抛砖引玉之用，让大家能开始对JVM性能调优的常用工具有所了解。
现实企业级Java开发中，有时候我们会碰到下面这些问题：
OutOfMemoryError，内存不足
内存泄露
线程死锁
锁争用（Lock Contention）
Java进程消耗CPU过高
......
这些问题在日常开发中可能被很多人忽视（比如有的人遇到上面的问题只是重启服务器或者调大内存，而不会深究问题根源），但能够理解并解决这些问题是Java程序员进阶的必备要求。本文将对一些常用的JVM性能调优监控工具进行介绍，希望能起抛砖引玉之用。本文参考了网上很多资料，难以一一列举，在此对这些资料的作者表示感谢！关于JVM性能调优相关的资料，请参考文末。
A、 jps(Java Virtual Machine Process Status Tool)
jps主要用来输出JVM中运行的进程状态信息。语法格式如下：
1
jps [options] [hostid]
如果不指定hostid就默认为当前主机或服务器。
命令行参数选项说明如下：
1
-q 不输出类名、Jar名和传入main方法的参数
2
-m 输出传入main方法的参数
3
-l 输出main类或Jar的全限名
4
-v 输出传入JVM的参数
比如下面：
1
root@ubuntu:/# jps -m -l
2
2458 org.artifactory.standalone.main.Main /usr/local/artifactory-2.2.5/etc/jetty.xml
3
29920 com.sun.tools.hat.Main -port 9998 /tmp/dump.dat
4
3149 org.apache.catalina.startup.Bootstrap start
5
30972 sun.tools.jps.Jps -m -l
6
8247 org.apache.catalina.startup.Bootstrap start
7
25687 com.sun.tools.hat.Main -port 9999 dump.dat
8
21711 mrf-center.jar
B、 jstack
jstack主要用来查看某个Java进程内的线程堆栈信息。语法格式如下：
1
jstack [option] pid
2
jstack [option] executable core
3
jstack [option] [server-id@]remote-hostname-or-ip
命令行参数选项说明如下：
1
-l long listings，会打印出额外的锁信息，在发生死锁时可以用jstack -l pid来观察锁持有情况
2
-m mixed mode，不仅会输出Java堆栈信息，还会输出C/C++堆栈信息（比如Native方法）
jstack可以定位到线程堆栈，根据堆栈信息我们可以定位到具体代码，所以它在JVM性能调优中使用得非常多。下面我们来一个实例找出某个Java进程中最耗费CPU的Java线程并定位堆栈信息，用到的命令有ps、top、printf、jstack、grep。
第一步先找出Java进程ID，我部署在服务器上的Java应用名称为mrf-center：
1
root@ubuntu:/# ps -ef | grep mrf-center | grep -v grep
2
root 21711 1 1 14:47 pts/3 00:02:10 java -jar mrf-center.jar
得到进程ID为21711，第二步找出该进程内最耗费CPU的线程，可以使用ps -Lfp pid或者ps -mp pid -o THREAD, tid, time或者top -Hp pid，我这里用第三个，输出如下：
转存失败
重新上传
取消
TIME列就是各个Java线程耗费的CPU时间，CPU时间最长的是线程ID为21742的线程，用
1
printf "%x\n" 21742
得到21742的十六进制值为54ee，下面会用到。
OK，下一步终于轮到jstack上场了，它用来输出进程21711的堆栈信息，然后根据线程ID的十六进制值grep，如下：
1
root@ubuntu:/# jstack 21711 | grep 54ee
2
"PollIntervalRetrySchedulerThread" prio=10 tid=0x00007f950043e000 nid=0x54ee in Object.wait() [0x00007f94c6eda000]
可以看到CPU消耗在PollIntervalRetrySchedulerThread这个类的Object.wait()，我找了下我的代码，定位到下面的代码：
01
// Idle wait
02
getLog().info("Thread [" + getName() + "] is idle waiting...");
03
schedulerThreadState = PollTaskSchedulerThreadState.IdleWaiting;
04
long now = System.currentTimeMillis();
05
long waitTime = now + getIdleWaitTime();
06
long timeUntilContinue = waitTime - now;
07
synchronized(sigLock) {
08
try {
09
if(!halted.get()) {
10
sigLock.wait(timeUntilContinue);
11
}
12
}
13
catch (InterruptedException ignore) {
14
}
15
}
它是轮询任务的空闲等待代码，上面的sigLock.wait(timeUntilContinue)就对应了前面的Object.wait()。
C、 jmap（Memory Map）和jhat（Java Heap Analysis Tool）
jmap用来查看堆内存使用状况，一般结合jhat使用。
jmap语法格式如下：
1
jmap [option] pid
2
jmap [option] executable core
3
jmap [option] [server-id@]remote-hostname-or-ip
如果运行在64位JVM上，可能需要指定-J-d64命令选项参数。
1
jmap -permstat pid
打印进程的类加载器和类加载器加载的持久代对象信息，输出：类加载器名称、对象是否存活（不可靠）、对象地址、父类加载器、已加载的类大小等信息，如下图：
转存失败
重新上传
取消
使用jmap -heap pid查看进程堆内存使用情况，包括使用的GC算法、堆配置参数和各代中堆内存使用情况。比如下面的例子：
01
root@ubuntu:/# jmap -heap 21711
02
Attaching to process ID 21711, please wait...
03
Debugger attached successfully.
04
Server compiler detected.
05
JVM version is 20.10-b01
06
07
using thread-local object allocation.
08
Parallel GC with 4 thread(s)
09
10
Heap Configuration:
11
MinHeapFreeRatio = 40
12
MaxHeapFreeRatio = 70
13
MaxHeapSize = 2067791872 (1972.0MB)
14
NewSize = 1310720 (1.25MB)
15
MaxNewSize = 17592186044415 MB
16
OldSize = 5439488 (5.1875MB)
17
NewRatio = 2
18
SurvivorRatio = 8
19
PermSize = 21757952 (20.75MB)
20
MaxPermSize = 85983232 (82.0MB)
21
22
Heap Usage:
23
PS Young Generation
24
Eden Space:
25
capacity = 6422528 (6.125MB)
26
used = 5445552 (5.1932830810546875MB)
27
free = 976976 (0.9317169189453125MB)
28
84.78829520089286% used
29
From Space:
30
capacity = 131072 (0.125MB)
31
used = 98304 (0.09375MB)
32
free = 32768 (0.03125MB)
33
75.0% used
34
To Space:
35
capacity = 131072 (0.125MB)
36
used = 0 (0.0MB)
37
free = 131072 (0.125MB)
38
0.0% used
39
PS Old Generation
40
capacity = 35258368 (33.625MB)
41
used = 4119544 (3.9287033081054688MB)
42
free = 31138824 (29.69629669189453MB)
43
11.683876009235595% used
44
PS Perm Generation
45
capacity = 52428800 (50.0MB)
46
used = 26075168 (24.867218017578125MB)
47
free = 26353632 (25.132781982421875MB)
48
49.73443603515625% used
49
....
使用jmap -histo[:live] pid查看堆内存中的对象数目、大小统计直方图，如果带上live则只统计活对象，如下：
01
root@ubuntu:/# jmap -histo:live 21711 | more
02
03
num #instances #bytes class name
04
----------------------------------------------
05
1: 38445 5597736 <constMethodKlass>
06
2: 38445 5237288 <methodKlass>
07
3: 3500 3749504 <constantPoolKlass>
08
4: 60858 3242600 <symbolKlass>
09
5: 3500 2715264 <instanceKlassKlass>
10
6: 2796 2131424 <constantPoolCacheKlass>
11
7: 5543 1317400 [I
12
8: 13714 1010768 [C
13
9: 4752 1003344 [B
14
10: 1225 639656 <methodDataKlass>
15
11: 14194 454208 java.lang.String
16
12: 3809 396136 java.lang.Class
17
13: 4979 311952 [S
18
14: 5598 287064 [[I
19
15: 3028 266464 java.lang.reflect.Method
20
16: 280 163520 <objArrayKlassKlass>
21
17: 4355 139360 java.util.HashMap$Entry
22
18: 1869 138568 [Ljava.util.HashMap$Entry;
23
19: 2443 97720 java.util.LinkedHashMap$Entry
24
20: 2072 82880 java.lang.ref.SoftReference
25
21: 1807 71528 [Ljava.lang.Object;
26
22: 2206 70592 java.lang.ref.WeakReference
27
23: 934 52304 java.util.LinkedHashMap
28
24: 871 48776 java.beans.MethodDescriptor
29
25: 1442 46144 java.util.concurrent.ConcurrentHashMap$HashEntry
30
26: 804 38592 java.util.HashMap
31
27: 948 37920 java.util.concurrent.ConcurrentHashMap$Segment
32
28: 1621 35696 [Ljava.lang.Class;
33
29: 1313 34880 [Ljava.lang.String;
34
30: 1396 33504 java.util.LinkedList$Entry
35
31: 462 33264 java.lang.reflect.Field
36
32: 1024 32768 java.util.Hashtable$Entry
37
33: 948 31440 [Ljava.util.concurrent.ConcurrentHashMap$HashEntry;
class name是对象类型，说明如下：
1
B byte
2
C char
3
D double
4
F float
5
I int
6
J long
7
Z boolean
8
[ 数组，如[I表示int[]
9
[L+类名 其他对象
还有一个很常用的情况是：用jmap把进程内存使用情况dump到文件中，再用jhat分析查看。jmap进行dump命令格式如下：
1
jmap -dump:format=b,file=dumpFileName
我一样地对上面进程ID为21711进行Dump：
1
root@ubuntu:/# jmap -dump:format=b,file=/tmp/dump.dat 21711
2
Dumping heap to /tmp/dump.dat ...
3
Heap dump file created
dump出来的文件可以用MAT、VisualVM等工具查看，这里用jhat查看：
01
root@ubuntu:/# jhat -port 9998 /tmp/dump.dat
02
Reading from /tmp/dump.dat...
03
Dump file created Tue Jan 28 17:46:14 CST 2014
04
Snapshot read, resolving...
05
Resolving 132207 objects...
06
Chasing references, expect 26 dots..........................
07
Eliminating duplicate references..........................
08
Snapshot resolved.
09
Started HTTP server on port 9998
10
Server is ready.
然后就可以在浏览器中输入主机地址:9998查看了：
转存失败
重新上传
取消
上面红线框出来的部分大家可以自己去摸索下，最后一项支持OQL（对象查询语言）。
D、jstat（JVM统计监测工具）
语法格式如下：
1
jstat [ generalOption | outputOptions vmid [interval[s|ms] [count]] ]
vmid是虚拟机ID，在Linux/Unix系统上一般就是进程ID。interval是采样时间间隔。count是采样数目。比如下面输出的是GC信息，采样时间间隔为250ms，采样数为4：
1
root@ubuntu:/# jstat -gc 21711 250 4
2
S0C S1C S0U S1U EC EU OC OU PC PU YGC YGCT FGC FGCT GCT
3
192.0 192.0 64.0 0.0 6144.0 1854.9 32000.0 4111.6 55296.0 25472.7 702 0.431 3 0.218 0.649
4
192.0 192.0 64.0 0.0 6144.0 1972.2 32000.0 4111.6 55296.0 25472.7 702 0.431 3 0.218 0.649
5
192.0 192.0 64.0 0.0 6144.0 1972.2 32000.0 4111.6 55296.0 25472.7 702 0.431 3 0.218 0.649
6
192.0 192.0 64.0 0.0 6144.0 2109.7 32000.0 4111.6 55296.0 25472.7 702 0.431 3 0.218 0.649
要明白上面各列的意义，先看JVM堆内存布局：
转存失败
重新上传
取消
可以看出：
1
堆内存 = 年轻代 + 年老代 + 永久代
2
年轻代 = Eden区 + 两个Survivor区（From和To）
现在来解释各列含义：
1
S0C、S1C、S0U、S1U：Survivor 0/1区容量（Capacity）和使用量（Used）
2
EC、EU：Eden区容量和使用量
3
OC、OU：年老代容量和使用量
4
PC、PU：永久代容量和使用量
5
YGC、YGT：年轻代GC次数和GC耗时
6
FGC、FGCT：Full GC次数和Full GC耗时
7
GCT：GC总耗时
其他JVM性能调优参考资料：
《Java虚拟机规范》
《Java Performance》
《Trouble Shooting Guide for JavaSE 6 with HotSpot VM》: http://www.oracle.com/technetwork/java/javase/tsg-vm-149989.pdf
《Effective Java》
VisualVM: http://docs.oracle.com/javase/7/docs/technotes/guides/visualvm/
jConsole: http://docs.oracle.com/javase/1.5.0/docs/guide/management/jconsole.html
Monitoring and Managing JavaSE 6 Applications: http://www.oracle.com/technetwork/articles/javase/monitoring-141801.html
原文路径：http://blog.youkuaiyun.com/wisgood/article/details/25343845
对应参数解释：
各种 Java Thread State 第一分析法则
使用 TDA 工具，看到大量 Java Thread State 的第一反应是：
1，线程状态为“waiting for monitor entry”：
意味着它 在等待进入一个临界区 ，所以它在”Entry Set“队列中等待。
此时线程状态一般都是 Blocked：
java.lang.Thread.State: BLOCKED (on object monitor)
2，线程状态为“waiting on condition”：
说明它在等待另一个条件的发生，来把自己唤醒，或者干脆它是调用了 sleep(N)。
此时线程状态大致为以下几种：
java.lang.Thread.State: WAITING (parking)：一直等那个条件发生；
java.lang.Thread.State: TIMED_WAITING (parking或sleeping)：定时的，那个条件不到来，也将定时唤醒自己。
3，如果大量线程在“waiting for monitor entry”：
可能是一个全局锁阻塞住了大量线程。
如果短时间内打印的 thread dump 文件反映，随着时间流逝，waiting for monitor entry 的线程越来越多，没有减少的趋势，可能意味着某些线程在临界区里呆的时间太长了，以至于越来越多新线程迟迟无法进入临界区。
4，如果大量线程在“waiting on condition”：
可能是它们又跑去获取第三方资源，尤其是第三方网络资源，迟迟获取不到Response，导致大量线程进入等待状态。
所以如果你发现有大量的线程都处在 Wait on condition，从线程堆栈看，正等待网络读写，这可能是一个网络瓶颈的征兆，因为网络阻塞导致线程无法执行。
线程状态为“in Object.wait()”：
说明它获得了监视器之后，又调用了 java.lang.Object.wait() 方法。
每个 Monitor在某个时刻，只能被一个线程拥有，该线程就是 “Active Thread”，而其它线程都是 “Waiting Thread”，分别在两个队列 “ Entry Set”和 “Wait Set”里面等候。在 “Entry Set”中等待的线程状态是 “Waiting for monitor entry”，而在 “Wait Set”中等待的线程状态是 “in Object.wait()”。
当线程获得了 Monitor，如果发现线程继续运行的条件没有满足，它则调用对象（一般就是被 synchronized 的对象）的 wait() 方法，放弃了 Monitor，进入 “Wait Set”队列。
此时线程状态大致为以下几种：
java.lang.Thread.State: TIMED_WAITING (on object monitor)；
java.lang.Thread.State: WAITING (on object monitor)；
一般都是RMI相关线程（RMI RenewClean、 GC Daemon、RMI Reaper），GC线程（Finalizer），引用对象垃圾回收线程（Reference Handler）等系统线程处于这种状态。
转存失败
重新上传
取消
图1 A Java Monitor
示范一：
下面这个线程在等待这个锁 0x00000000fe7e3b50，等待进入临界区：
"RMI TCP Connection(64896)-172.16.52.118" daemon prio=10 tid=0x00000000405a6000 nid=0x68fe waiting for monitor entry [0x00007f2be65a3000]
java.lang.Thread.State: BLOCKED (on object monitor)
at com.xyz.goods.service.impl.GoodsServiceImpl.findChanellGoodsCountWithCache(GoodsServiceImpl.java:1734)
- waiting to lock <0x00000000fe7e3b50> (a java.lang.String)
那么谁持有这个锁呢？
是另一个先调用了 findChanellGoodsCountWithCache 函数的线程：
"RMI TCP Connection(64878)-172.16.52.117" daemon prio=10 tid=0x0000000040822000 nid=0x6841 runnable [0x00007f2be76b3000]
java.lang.Thread.State: RUNNABLE
at java.net.SocketInputStream.socketRead0(Native Method)
at java.net.SocketInputStream.read(SocketInputStream.java:129)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read1(BufferedInputStream.java:258)
at java.io.BufferedInputStream.read(BufferedInputStream.java:317)
- locked <0x00000000af4ed638> (a java.io.BufferedInputStream)
at org.bson.io.Bits.readFully(Bits.java:35)
at org.bson.io.Bits.readFully(Bits.java:28)
at com.mongodb.Response.<init>(Response.java:35)
at com.mongodb.DBPort.go(DBPort.java:110)
- locked <0x00000000af442d48> (a com.mongodb.DBPort)
at com.mongodb.DBPort.go(DBPort.java:75)
- locked <0x00000000af442d48> (a com.mongodb.DBPort)
at com.mongodb.DBPort.call(DBPort.java:65)
at com.mongodb.DBTCPConnector.call(DBTCPConnector.java:202)
at com.mongodb.DBApiLayer$MyCollection.__find(DBApiLayer.java:296)
at com.mongodb.DB.command(DB.java:152)
at com.mongodb.DBCollection.getCount(DBCollection.java:760)
at com.mongodb.DBCollection.getCount(DBCollection.java:731)
at com.mongodb.DBCollection.count(DBCollection.java:697)
at com.xyz.goods.manager.MongodbManager.count(MongodbManager.java:202)
at com.xyz.goods.service.impl.GoodsServiceImpl.findChanellGoodsCount(GoodsServiceImpl.java:1787)
at com.xyz.goods.service.impl.GoodsServiceImpl.findChanellGoodsCountWithCache(GoodsServiceImpl.java:1739)
- locked <0x00000000fe7e3b50> (a java.lang.String)
示范二：
等待另一个条件发生来将自己唤醒：
"RMI TCP Connection(idle)" daemon prio=10 tid=0x00007fd50834e800 nid=0x56b2 waiting on condition [0x00007fd4f1a59000]
java.lang.Thread.State: TIMED_WAITING (parking)
at sun.misc.Unsafe.park(Native Method)
- parking to wait for <0x00000000acd84de8> (a java.util.concurrent.SynchronousQueue$TransferStack)
at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:198)
at java.util.concurrent.SynchronousQueue$TransferStack.awaitFulfill(SynchronousQueue.java:424)
at java.util.concurrent.SynchronousQueue$TransferStack.transfer(SynchronousQueue.java:323)
at java.util.concurrent.SynchronousQueue.poll(SynchronousQueue.java:874)
at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:945)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:907)
at java.lang.Thread.run(Thread.java:662)
1）“TIMED_WAITING (parking)”中的 timed_waiting 指等待状态，但这里指定了时间，到达指定的时间后自动退出等待状态；parking指线程处于挂起中。
2）“waiting on condition”需要与堆栈中的“parking to wait for <0x00000000acd84de8> (a java.util.concurrent.SynchronousQueue$TransferStack)” 结合来看。首先，本线程肯定是在等待某个条件的发生，来把自己唤醒。其次，SynchronousQueue 并不是一个队列，只是线程之间移交信息的机制，当我们把一个元素放入到 SynchronousQueue 中时必须有另一个线程正在等待接受移交的任务，因此这就是本线程在等待的条件。
示范三：
"RMI RenewClean-[172.16.50.182:4888]" daemon prio=10 tid=0x0000000040d2c800 nid=0x97e in Object.wait() [0x00007f9ccafd0000]
java.lang.Thread.State: TIMED_WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x0000000799b032d8> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:118)
- locked <0x0000000799b032d8> (a java.lang.ref.ReferenceQueue$Lock)
at sun.rmi.transport.DGCClient$EndpointEntry$RenewCleanThread.run(DGCClient.java:516)
at java.lang.Thread.run(Thread.java:662)
一 linux服务器性能查看
1.1 cpu性能查看
1、查看物理cpu个数：
cat /proc/cpuinfo |grep "physical id"|sort|uniq|wc -l
2、查看每个物理cpu中的core个数：
cat /proc/cpuinfo |grep "cpu cores"|wc -l
3、逻辑cpu的个数：
cat /proc/cpuinfo |grep "processor"|wc -l
物理cpu个数*核数=逻辑cpu个数（不支持超线程技术的情况下）
1.2 内存查看
1、查看内存使用情况：
#free -m
total used free shared buffers cached
Mem: 3949 2519 1430 0 189 1619
-/+ buffers/cache: 710 3239
Swap: 3576 0 3576
total：内存总数
used：已经使用的内存数
free：空闲内存数
shared：多个进程共享的内存总额
- buffers/cache：(已用)的内存数，即used-buffers-cached
+ buffers/cache：(可用)的内存数，即free+buffers+cached
Buffer Cache用于针对磁盘块的读写；
Page Cache用于针对文件inode的读写，这些Cache能有效地缩短I/O系统调用的时间。
对操作系统来说free/used是系统可用/占用的内存；
对应用程序来说-/+ buffers/cache是可用/占用内存,因为buffers/cache很快就会被使用。
我们工作时候应该从应用角度来看。
1.3 硬盘查看
1、查看硬盘及分区信息：
fdisk -l
2、查看文件系统的磁盘空间占用情况：
df -h
3、查看硬盘的I/O性能（每隔一秒显示一次，显示5次）：
iostat -x 1 5
iostat是含在套装systat中的,可以用yum -y install systat来安装。
常关注的参数：
如%util接近100%,说明产生的I/O请求太多，I/O系统已经满负荷，该磁盘可能存在瓶颈。
如idle小于70%，I/O的压力就比较大了，说明读取进程中有较多的wait。
4、查看linux系统中某目录的大小：
du -sh /root
如发现某个分区空间接近用完，可以进入该分区的挂载点，用以下命令找出占用空间最多的文件或目录，然后按照从大到小的顺序，找出系统中占用最多空间的前10个文件或目录：
du -cksh *|sort -rn|head -n 10
1.4 查看平均负载
有时候系统响应很慢，但又找不到原因，这时就要查看平均负载了，看它是否有大量的进程在排队等待。
最简单的命令：
uptime--查看过去的1分钟、5分钟和15分钟内进程队列中的平均进程数量。
还有动态命令top
我们只关心以下部分：
top - 21:33:09 up 1:00, 1 user, load average: 0.00, 0.01, 0.05
如果每个逻辑cpu当前的活动进程不大于3，则系统性能良好；
如果每个逻辑cpu当前的活动进程不大于4，表示可以接受；
如果每个逻辑cpu当前的活动进程大于5，则系统性能问题严重。
一般计算方法：负载值/逻辑cpu个数
还可以结合vmstat命令来判断系统是否繁忙，其中：
procs
r：等待运行的进程数。
b：处在非中断睡眠状态的进程数。
w：被交换出去的可运行的进程数。
memeory
swpd：虚拟内存使用情况，单位为KB。
free：空闲的内存，单位为KB。
buff：被用来作为缓存的内存数，单位为KB。
swap
si：从磁盘交换到内存的交换页数量，单位为KB。
so：从内存交换到磁盘的交换页数量，单位为KB。
io
bi：发送到块设备的块数，单位为KB。
bo：从块设备接受的块数，单位为KB。
system
in：每秒的中断数，包括时钟中断。
cs：每秒的环境切换次数。
cpu
按cpu的总使用百分比来显示。
us：cpu使用时间。
sy：cpu系统使用时间。
id：闲置时间。
1.5 其他参数
查看内核版本号：
uname -a
简化命令：uname -r
查看系统是32位还是64位的：
file /sbin/init
查看发行版：
cat /etc/issue
或lsb_release -a
查看系统已载入的相关模块：
lsmod
查看pci设置：
lspci
二 Linux服务器性能评估
2.1.1 影响Linux服务器性能的因素
1. 操作系统级
CPU
内存
磁盘I/O带宽
网络I/O带宽
2. 程序应用级
2.1.2 系统性能评估标准
影响性能因素
好
坏
糟糕
CPU
user% + sys%< 70%
user% + sys%= 85%
user% + sys% >=90%
内存
Swap In（si）＝0 Swap Out（so）＝0
Per CPU with 10 page/s
More Swap In & Swap Out
磁盘
iowait % < 20%
iowait % =35%
iowait % >= 50%
其中：
%user：表示CPU处在用户模式下的时间百分比。
%sys：表示CPU处在系统模式下的时间百分比。
%iowait：表示CPU等待输入输出完成时间的百分比。
swap in：即si，表示虚拟内存的页导入，即从SWAP DISK交换到RAM
swap out：即so，表示虚拟内存的页导出，即从RAM交换到SWAP DISK
2.1.3 系统性能分析工具
1.常用系统命令
Vmstat、sar、iostat、netstat、free、ps、top等
2.常用组合方式
vmstat、sar、iostat检测是否是CPU瓶颈
free、vmstat检测是否是内存瓶颈
iostat检测是否是磁盘I/O瓶颈
netstat检测是否是网络带宽瓶颈
2.1.4 Linux性能评估与优化
系统整体性能评估（uptime命令）
uptime
16:38:00 up 118 days, 3:01, 5 users,load average: 1.22, 1.02, 0.91
注意：
load average三值大小一般不能大于系统CPU的个数。
系统有8个CPU,如load average三值长期大于8，说明CPU很繁忙，负载很高，可能会影响系统性能。
但偶尔大于8，一般不会影响系统性能。
如load average输出值小于CPU个数，则表示CPU有空闲时间片，比如本例中的输出，CPU是非常空闲的
2.2.1 CPU性能评估
1.利用vmstat命令监控系统CPU
显示系统各种资源之间相关性能简要信息，主要看CPU负载情况。
下面是vmstat命令在某个系统的输出结果：
[root@node1 ~]#vmstat 2 3
procs
———–memory———- —swap– —–io—- –system– —–cpu——
r b swpd freebuff cache si so bi bo incs us sy idwa st
0 0 0 162240 8304 67032 0 0 13 21 1007 23 0 1 98 0 0
0 0 0 162240 8304 67032 0 0 1 0 1010 20 0 1 100 0 0
0 0 0 162240 8304 67032 0 0 1 1 1009 18 0 1 99 0 0
Procs
r--运行和等待cpu时间片的进程数，这个值如果长期大于系统CPU的个数，说明CPU不足，需要增加CPU
b--在等待资源的进程数，比如正在等待I/O、或者内存交换等。
CPU
us
用户进程消耗的CPU 时间百分比。
us的值比较高时，说明用户进程消耗的cpu时间多，但是如果长期大于50%，就需要考虑优化程序或算法。
sy
内核进程消耗的CPU时间百分比。Sy的值较高时，说明内核消耗的CPU资源很多。
根据经验，us+sy的参考值为80%，如果us+sy大于 80%说明可能存在CPU资源不足。
2.利用sar命令监控系统CPU
sar对系统每方面进行单独统计，但会增加系统开销，不过开销可以评估，对系统的统计结果不会有很大影响。
下面是sar命令对某个系统的CPU统计输出：
[root@webserver ~]# sar -u 3 5
Linux
2.6.9-42.ELsmp (webserver) 11/28/2008_i686_
(8 CPU)
11:41:24
AM CPU %user %nice%system
%iowait %steal %idle
11:41:27
AM all 0.88 0.00 0.29 0.00 0.00 98.83
11:41:30
AM all 0.13 0.00 0.17 0.21 0.00 99.50
11:41:33
AM all 0.04 0.00 0.04 0.00 0.00 99.92
11:41:36
AM all 90.08 0.00 0.13 0.16 0.00 9.63
11:41:39
AM all 0.38 0.00 0.17 0.04 0.00 99.41
Average:
all 0.34 0.00 0.16 0.05 0.00 99.45
输出解释如下：
%user列显示了用户进程消耗的CPU 时间百分比。
%nice列显示了运行正常进程所消耗的CPU 时间百分比。
%system列显示了系统进程消耗的CPU时间百分比。
%iowait列显示了IO等待所占用的CPU时间百分比
%steal列显示了在内存相对紧张的环境下pagein强制对不同的页面进行的steal操作 。
%idle列显示了CPU处在空闲状态的时间百分比。
问题
你是否遇到过系统CPU整体利用率不高，而应用缓慢的现象？
在一个多CPU的系统中，如果程序使用了单线程，会出现这么一个现象，CPU的整体使用率不高，但是系统应用却响应缓慢，这可能是由于程序使用单线程的原因，单线程只使用一个CPU，导致这个CPU占用率为100%，无法处理其它请求，而其它的CPU却闲置，这就导致了整体CPU使用率不高，而应用缓慢现象的发生。
2.3.1 内存性能评估
1.利用free指令监控内存
free是监控Linux内存使用状况最常用的指令，看下面的一个输出：
[root@webserver ~]# free -m
total
used freeshared
buffers cached
Mem:
8111 7185 926 0 243 6299
-/+
buffers/cache:
643 7468
Swap:
8189 0 8189
经验公式：
应用程序可用内存/系统物理内存>70%，表示系统内存资源非常充足，不影响系统性能;
应用程序可用内存/系统物理内存<20%，表示系统内存资源紧缺，需要增加系统内存;
20%<应用程序可用内存/系统物理内存<70%，表示系统内存资源基本能满足应用需求，暂时不影响系统性能
2.利用vmstat命令监控内存
[root@node1
~]#
vmstat 2 3
procs
———–memory———- —swap– —–io—- –system– —–cpu——
r b swpd freebuff cache si so bi bo incs us sy idwa st
0 0 0 162240 8304 67032 0 0 13 21 1007 23 0 1 98 0 0
0 0 0 162240 8304 67032 0 0 1 0 1010 20 0 1 100 0 0
0 0 0 162240 8304 67032 0 0 1 1 1009 18 0 1 99 0 0
memory
swpd--切换到内存交换区的内存数量（k为单位)。如swpd值偶尔非0，不影响系统性能
free--当前空闲的物理内存数量（k为单位）
buff--buffers cache的内存数量，一般对块设备的读写才需要缓冲
cache--page cached的内存数量
一般作为文件系统cached，频繁访问的文件都会被cached，如cache值较大，说明cached的文件数较多，如果此时IO中bi比较小，说明文件系统效率比较好。
swap
si--由磁盘调入内存，也就是内存进入内存交换区的数量。
so--由内存调入磁盘，也就是内存交换区进入内存的数量。
si、so的值长期不为0，表示系统内存不足。需增加系统内存。
2.4.1磁盘I/O性能评估
1.磁盘存储基础
频繁访问的文件或数据尽可能用内存读写代替直接磁盘I/O，效率高千倍。
将经常进行读写的文件与长期不变的文件独立出来，分别放置到不同的磁盘设备上。
对于写操作频繁的数据，可以考虑使用裸设备代替文件系统。
裸设备优点：
数据可直接读写，不需经过操作系统级缓存，节省内存资源，避免内存资源争用;
避免文件系统级维护开销，如文件系统需维护超级块、I-node等;
避免了操作系统cache预读功能，减少了I/O请求
使用裸设备的缺点是：
数据管理、空间管理不灵活，需要很专业的人来操作。
2.利用iostat评估磁盘性能
[root@webserver ~]# iostat -d 2 3
Linux
2.6.9-42.ELsmp (webserver) 12/01/2008_i686_
(8 CPU)
Device:
tps Blk_read/sBlk_wrtn/sBlk_read
Blk_wrtn
sda 1.87 2.58 114.12 6479462 286537372
Device:
tps Blk_read/sBlk_wrtn/sBlk_read
Blk_wrtn
sda
0.00 0.00 0.00 0 0
Device:
tps Blk_read/sBlk_wrtn/sBlk_read
Blk_wrtn
sda
1.00 0.00 12.00 0 24
解释如下：
Blk_read/s--每秒读取数据块数
Blk_wrtn/s--每秒写入数据块数
Blk_read--读取的所有块数
Blk_wrtn--写入的所有块数
可通过Blk_read/s和Blk_wrtn/s值对磁盘的读写性能有一个基本的了解.
如Blk_wrtn/s值很大，表示磁盘写操作频繁，考虑优化磁盘或程序，
如Blk_read/s值很大，表示磁盘直接读操作很多，可将读取的数据放入内存
规则遵循：
长期的、超大的数据读写，肯定是不正常的，这种情况一定会影响系统性能。
3.利用sar评估磁盘性能
通过“sar –d”组合，可以对系统的磁盘IO做一个基本的统计，请看下面的一个输出：
[root@webserver ~]# sar -d 2 3
Linux
2.6.9-42.ELsmp (webserver) 11/30/2008_i686_
(8 CPU)
11:09:33
PM DEV tps rd_sec/swr_sec/savgrq-sz
avgqu-sz await svctm %util
11:09:35
PM dev8-0 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00
11:09:35
PM DEV tps rd_sec/swr_sec/savgrq-sz
avgqu-sz await svctm %util
11:09:37
PM dev8-0 1.00 0.00 12.00 12.00 0.00 0.00 0.00 0.00
11:09:37
PM DEV tps rd_sec/swr_sec/savgrq-sz
avgqu-sz await svctm %util
11:09:39
PM dev8-0 1.99 0.00 47.76 24.00 0.00 0.50 0.25 0.05
Average:
DEV tps rd_sec/swr_sec/savgrq-sz
avgqu-sz await svctm %util
Average:
dev8-0 1.00 0.00 19.97 20.00 0.00 0.33 0.17 0.02
参数含义：
await--平均每次设备I/O操作等待时间（毫秒）
svctm--平均每次设备I/O操作的服务时间（毫秒）
%util--一秒中有百分之几的时间用于I/O操作
对磁盘IO性能评判标准：
正常svctm应小于await值，而svctm和磁盘性能有关，CPU、内存负荷也会对svctm值造成影响，过多的请求也会间接的导致svctm值的增加。
await值取决svctm和I/O队列长度以及I/O请求模式，
如果svctm的值与await很接近，表示几乎没有I/O等待，磁盘性能很好，
如果await的值远高于svctm的值，则表示I/O队列等待太长，系统上运行的应用程序将变慢，
此时可以通过更换更快的硬盘来解决问题。
%util--衡量磁盘I/O重要指标，
如%util接近100%，表示磁盘产生的I/O请求太多，I/O系统已经满负荷工作，该磁盘可能存在瓶颈。
可优化程序或者 通过更换 更高、更快的磁盘。
2.5.1. 网络性能评估
（1）通过ping命令检测网络的连通性
（2）通过netstat –i组合检测网络接口状况
（3）通过netstat –r组合检测系统的路由表信息
（4）通过sar –n组合显示系统的网络运行状态
三 Linux服务器性能调优
1.为磁盘I/O调整Linux内核电梯算法
选择文件系统后，该算法可以平衡低延迟需求，收集足够数据，有效组织对磁盘读写请求。
2.禁用不必要的守护进程，节省内存和CPU资源
许多守护进程或服务通常非必需，消耗宝贵内存和CPU时间。将服务器置于险地。
禁用可加快启动时间，释放内存。
减少CPU要处理的进程数
一些应被禁用的Linux守护进程，默认自动运行：
序号 守护进程 描述
1 Apmd 高级电源管理守护进程
2 Nfslock 用于NFS文件锁定
3 Isdn ISDN Moderm支持
4 Autofs 在后台自动挂载文件系统(如自动挂载CD-ROM)
5 Sendmail 邮件传输代理
6 Xfs X Window的字体服务器
3.关掉GUI
4、清理不需要的模块或功能
服务器软件包中太多被启动的功能或模块实际上是不需要的(如Apache中的许多功能模块)，禁用掉有助于提高系统内存可用量，腾出资源给那些真正需要的软件，让它们运行得更快。
5、禁用控制面板
在Linux中，有许多流行的控制面板，如Cpanel，Plesk，Webmin和phpMyAdmin等，禁用释放出大约120MB内存，内存使用量大约下降30-40%。
6、改善Linux Exim服务器性能
使用DNS缓存守护进程，可降低解析DNS记录需要的带宽和CPU时间，DNS缓存通过消除每次都从根节点开始查找DNS记录的需求，从而改善网络性能。
Djbdns是一个非常强大的DNS服务器，它具有DNS缓存功能，Djbdns比BIND DNS服务器更安全，性能更好，可以直接通过http://cr.yp.to/下载，或通过Red Hat提供的软件包获得。
7、使用AES256增强gpg文件加密安全
为提高备份文件或敏感信息安全，许多Linux系统管理员都使用gpg进行加密，在使用gpg时，最好指定gpg使用AES256加密算法，AES256使用256位密钥，它是一个开放的加密算法，美国国家安全局(NSA)使用它保护绝密信息。
8、远程备份服务安全
安全是选择远程备份服务最重要的因素，大多数系统管理员都害怕两件事：(黑客)可以删除备份文件，不能从备份恢复系统。
为了保证备份文件100%的安全，备份服务公司提供远程备份服务器，使用scp脚本或RSYNC通过SSH传输数据，这样，没有人可以直接进入和访问远程系统，因此，也没有人可以从备份服务删除数据。在选择远程备份服务提供商时，最好从多个方面了解其服务强壮性，如果可以，可以亲自测试一下。
9、更新默认内核参数设置
为了顺利和成功运行企业应用程序，如数据库服务器，可能需要更新一些默认的内核参数设置，例如，2.4.x系列内核消息队列参数msgmni有一个默认值(例如，共享内存，或shmmax在Red Hat系统上默认只有33554432字节)，它只允许有限的数据库并发连接，下面为数据库服务器更好地运行提供了一些建议值(来自IBM DB2支持网站)：
kernel.shmmax=268435456 (32位)
kernel.shmmax=1073741824 (64位)
kernel.msgmni=1024
fs.file-max=8192
kernel.sem=”250 32000 32 1024″
10、优化TCP
优化TCP协议有助于提高网络吞吐量，跨广域网的通信使用的带宽越大，延迟时间越长时，建议使用越大的TCP Linux大小，以提高数据传输速率，TCP Linux大小决定了发送主机在没有收到数据传输确认时，可以向接收主机发送多少数据。
11、选择正确的文件系统
使用ext4文件系统取代ext3
● Ext4是ext3文件系统的增强版，扩展了存储限制
●具有日志功能，保证高水平的数据完整性(在非正常关闭事件中)
●非正常关闭和重启时，它不需要检查磁盘(这是一个非常耗时的动作)
●更快的写入速度，ext4日志优化了硬盘磁头动作
12、使用noatime文件系统挂载选项
在文件系统启动配置文件fstab中使用noatime选项，如果使用了外部存储，这个挂载选项可以有效改善性能。
13、调整Linux文件描述符限制
Linux限制了任何进程可以打开的文件描述符数量，默认限制是每进程1024，这些限制可能会阻碍基准测试客户端(如httperf和apachebench)和Web服务器本身获得最佳性能，Apache每个连接使用一个进程，因此不会受到影响，但单进程Web服务器，如Zeus是每连接使用一个文件描述符，因此很容易受默认限制的影响。
打开文件限制是一个可以用ulimit命令调整的限制，ulimit -aS命令显示当前的限制，ulimit -aH命令显示硬限制(在未调整/proc中的内核参数前，你不能增加限制)。
Linux第三方应用程序性能技巧
对于运行在Linux上的第三方应用程序，一样有许多性能优化技巧，这些技巧可以帮助你提高Linux服务器的性能，降低运行成本。
14、正确配置MySQL
为了给MySQL分配更多的内存，可设置MySQL缓存大小，要是MySQL服务器实例使用了更多内存，就减少缓存大小，如果MySQL在请求增多时停滞不动，就增加MySQL缓存。
15、正确配置Apache
检查Apache使用了多少内存，再调整StartServers和MinSpareServers参数，以释放更多的内存，将有助于你节省30-40%的内存。
16、分析Linux服务器性能
提高系统效率最好的办法是找出导致整体速度下降的瓶颈并解决掉，下面是找出系统关键瓶颈的一些基本技巧：
● 当大型应用程序，如OpenOffice和Firefox同时运行时，计算机可能会开始变慢，内存不足的出现几率更高。
● 如果启动时真的很慢，可能是应用程序初次启动需要较长的加载时间，一旦启动好后运行就正常了，否则很可能是硬盘太慢了。
●CPU负载持续很高，内存也够用，但CPU利用率很低，可以使用CPU负载分析工具监控负载时间。
17、学习5个Linux性能命令
使用几个命令就可以管理Linux系统的性能了，下面列出了5个最常用的Linux性能命令，包括
top、vmstat、iostat、free和sar，它们有助于系统管理员快速解决性能问题。
(1)top
当前内核服务的任务，还显示许多主机状态的统计数据，默认情况下，它每隔5秒自动更新一次。
如：当前正常运行时间，系统负载，进程数量和内存使用率，
此外，这个命令也显示了那些使用最多CPU时间的进程(包括每个进程的各种信息，如运行用户，执行的命令等)。
(2)vmstat
Vmstat命令提供当前CPU、IO、进程和内存使用率的快照，它和top命令类似，自动更新数据，如：
$ vmstat 10
(3)iostat
Iostat提供三个报告：CPU利用率、设备利用率和网络文件系统利用率，使用-c，-d和-h参数可以分别独立显示这三个报告。
(4)free
显示主内存和交换空间内存统计数据，指定-t参数显示总内存，指定-b参数按字节为单位，使用-m则以兆为单位，默认情况下千字节为单位。
Free命令也可以使用-s参数加一个延迟时间(单位：秒)连续运行，如：
$ free -s 5
(5)sar
收集，查看和记录性能数据，这个命令比前面几个命令历史更悠久，它可以收集和显示较长周期的数据。
其它
下面是一些归类为其它的性能技巧：
18、将日志文件转移到内存中
当一台机器处于运行中时，最好是将系统日志放在内存中，当系统关闭时再将其复制到硬盘，当你运行一台开启了syslog功能的笔记本电脑或移动设备时，ramlog可以帮助你提高系统电池或移动设备闪存驱动器的寿命，使用ramlog的一个好处是，不用再担心某个守护进程每隔30秒向syslog发送一条消息，放在以前，硬盘必须随时保持运转，这样对硬盘和电池都不好。
19、先打包，后写入
在内存中划分出固定大小的空间保存日志文件，这意味着笔记本电脑硬盘不用一直保持运转，只有当某个守护进程需要写入日志时才运转，注意ramlog使用的内存空间大小是固定的，否则系统内存会很快被用光，如果笔记本使用固态硬盘，可以分配50-80MB内存给ramlog使用，ramlog可以减少许多写入周期，极大地提高固态硬盘的使用寿命。
20、一般调优技巧
尽可能使用静态内容替代动态内容，如果你在生成天气预告，或其它每隔1小时就必须更新的数据，最好是写一个程序，每隔1小时生成一个静态的文件，而不是让用户运行一个CGI动态地生成报告。
为动态应用程序选择最快最合适的API，CGI可能最容易编程，但它会为每个请求产生一个进程，通常，这是一个成本很高，且不必要的过程，FastCGI是更好的选择，和Apache的mod_perl一样，都可以极大地提高应用程序的性能。
种一棵树，最好的时间是十年前，其次是现在。
vi /etc/sysctl.conf
fs.file-max = 999999
net.ipv4.tcp_fin_timeout = 30
net.ipv4.conf.default.rp_filter = 1
net.ipv4.conf.all.rp_filter = 1
net.ipv4.tcp_syncookies = 0
net.ipv6.conf.all.disable_ipv6 = 1
net.ipv4.tcp_synack_retries = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_timestamps = 0
net.ipv4.tcp_keepalive_time = 300
net.core.netdev_max_backlog = 8096
net.ipv4.ip_local_port_range = 1024 65500
net.ipv4.tcp_window_scaling = 1
net.ipv4.tcp_max_syn_backlog = 3240000
net.core.somaxconn = 65535
net.ipv4.tcp_max_tw_buckets = 6000
net.ipv4.tcp_max_orphans = 262144
net.core.rmem_default = 8388608
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216
net.ipv4.tcp_congestion_control = cubic
sysctl -p
nginx.conf配置：
user root;
worker_rlimit_nofile 409600;
worker_processes 8;
error_log logs/error.log;
events {
use epoll;
worker_connections 204800;
multi_accept on;
accept_mutex off;
}
http {
include mime.types;
default_type application/octet-stream;
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'$upstream_addr $upstream_response_time $request_time '
'"$http_user_agent" "$http_x_forwarded_for"';
#access_log logs/access.log main;
#access_log off;
#error_log logs/error.log crit;
sendfile on;
tcp_nopush on;
server_tokens off;
tcp_nodelay on;
keepalive_timeout 300;
keepalive_requests 200000;
client_body_timeout 3;
client_header_timeout 3;
send_timeout 3;
gzip on;
gzip_min_length 1k;
gzip_http_version 1.0;
gzip_buffers 30 64k;
gzip_comp_level 9;
gzip_proxied expired no-cache no-store private auth;
gzip_types text/plain text/css text/javascript application/json application/x-javascript text/xml application/xml;
gzip_vary on;
proxy_temp_path /tmp/temp_dir;
proxy_cache_path /tmp/cache levels=1:2 keys_zone=cache_one:10m inactive=1d max_size=1500M;
upstream test2 {
sticky;
server 19.14.132.94:80 max_fails=2 fail_timeout=3s;
server 19.14.132.95:80 max_fails=2 fail_timeout=3s;
server 19.14.132.96:80 max_fails=2 fail_timeout=3s;
keepalive 2000;
}
upstream test1 {
sticky;
server 19.14.132.91:9001;
server 19.14.132.93:9001;
check interval=3000 rise=2 fall=3 timeout=30000 type=http;
check_http_send "GET / HTTP/1.0\r\nconnection: keep-alive\r\n\r\n";
check_http_expect_alive http_2xx http_3xx http_4xx;
}
server {
listen 80 reuseport;
server_name localhost;
charset utf-8;
client_max_body_size 30m;
client_body_buffer_size 2048k;
proxy_connect_timeout 30;
proxy_send_timeout 3;
proxy_read_timeout 3;
proxy_buffer_size 64k;
proxy_buffers 12 64k;
proxy_busy_buffers_size 64k;
proxy_temp_file_write_size 128k;
proxy_max_temp_file_size 30m;
proxy_intercept_errors off;
proxy_ignore_client_abort on;
add_header X-Cache $upstream_cache_status;
location ~* "\.(jpg|jpeg|png|gif|html|css|js)$" {
proxy_pass http://test2;
proxy_redirect off;
proxy_set_header Host $host;
proxy_cache cache_one;
proxy_cache_valid 200 302 1h;
proxy_cache_valid 301 1d;
proxy_cache_valid any 1d;
expires 1d;
}
location / {
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_set_header X-NginX-Proxy true;
proxy_set_header Connection "";
proxy_set_header X-Forwarded-Server $host;
proxy_set_header X-Forwarded-Host $host;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_pass http://test2;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}
}
如果不指定hostid就默认为当前主机或服务器。
命令行参数选项说明如下：
1
-q 不输出类名、Jar名和传入main方法的参数
2
-m 输出传入main方法的参数
3
-l 输出main类或Jar的全限名
4
-v 输出传入JVM的参数
比如下面：
1
root@ubuntu:/# jps -m -l
2
2458 org.artifactory.standalone.main.Main /usr/local/artifactory-2.2.5/etc/jetty.xml
3
29920 com.sun.tools.hat.Main -port 9998 /tmp/dump.dat
4
3149 org.apache.catalina.startup.Bootstrap start
5
30972 sun.tools.jps.Jps -m -l
6
8247 org.apache.catalina.startup.Bootstrap start
7
25687 com.sun.tools.hat.Main -port 9999 dump.dat
8
21711 mrf-center.jar
B、 jstack
jstack主要用来查看某个Java进程内的线程堆栈信息。语法格式如下：
1
jstack [option] pid
2
jstack [option] executable core
3
jstack [option] [server-id@]remote-hostname-or-ip
命令行参数选项说明如下：
1
-l long listings，会打印出额外的锁信息，在发生死锁时可以用jstack -l pid来观察锁持有情况
2
-m mixed mode，不仅会输出Java堆栈信息，还会输出C/C++堆栈信息（比如Native方法）
jstack可以定位到线程堆栈，根据堆栈信息我们可以定位到具体代码，所以它在JVM性能调优中使用得非常多。下面我们来一个实例找出某个Java进程中最耗费CPU的Java线程并定位堆栈信息，用到的命令有ps、top、printf、jstack、grep。
第一步先找出Java进程ID，我部署在服务器上的Java应用名称为mrf-center：
1
root@ubuntu:/# ps -ef | grep mrf-center | grep -v grep
2
root 21711 1 1 14:47 pts/3 00:02:10 java -jar mrf-center.jar
得到进程ID为21711，第二步找出该进程内最耗费CPU的线程，可以使用ps -Lfp pid或者ps -mp pid -o THREAD, tid, time或者top -Hp pid，我这里用第三个，输出如下：
转存失败
重新上传
取消
TIME列就是各个Java线程耗费的CPU时间，CPU时间最长的是线程ID为21742的线程，用
1
printf "%x\n" 21742
得到21742的十六进制值为54ee，下面会用到。
OK，下一步终于轮到jstack上场了，它用来输出进程21711的堆栈信息，然后根据线程ID的十六进制值grep，如下：
1
root@ubuntu:/# jstack 21711 | grep 54ee
2
"PollIntervalRetrySchedulerThread" prio=10 tid=0x00007f950043e000 nid=0x54ee in Object.wait() [0x00007f94c6eda000]
可以看到CPU消耗在PollIntervalRetrySchedulerThread这个类的Object.wait()，我找了下我的代码，定位到下面的代码：
01
// Idle wait
02
getLog().info("Thread [" + getName() + "] is idle waiting...");
03
schedulerThreadState = PollTaskSchedulerThreadState.IdleWaiting;
04
long now = System.currentTimeMillis();
05
long waitTime = now + getIdleWaitTime();
06
long timeUntilContinue = waitTime - now;
07
synchronized(sigLock) {
08
try {
09
if(!halted.get()) {
10
sigLock.wait(timeUntilContinue);
11
}
12
}
13
catch (InterruptedException ignore) {
14
}
15
}
它是轮询任务的空闲等待代码，上面的sigLock.wait(timeUntilContinue)就对应了前面的Object.wait()。
C、 jmap（Memory Map）和jhat（Java Heap Analysis Tool）
jmap用来查看堆内存使用状况，一般结合jhat使用。
jmap语法格式如下：
1
jmap [option] pid
2
jmap [option] executable core
3
jmap [option] [server-id@]remote-hostname-or-ip
如果运行在64位JVM上，可能需要指定-J-d64命令选项参数。
1
jmap -permstat pid
打印进程的类加载器和类加载器加载的持久代对象信息，输出：类加载器名称、对象是否存活（不可靠）、对象地址、父类加载器、已加载的类大小等信息，如下图：
转存失败
重新上传
取消
使用jmap -heap pid查看进程堆内存使用情况，包括使用的GC算法、堆配置参数和各代中堆内存使用情况。比如下面的例子：
01
root@ubuntu:/# jmap -heap 21711
02
Attaching to process ID 21711, please wait...
03
Debugger attached successfully.
04
Server compiler detected.
05
JVM version is 20.10-b01
06
07
using thread-local object allocation.
08
Parallel GC with 4 thread(s)
09
10
Heap Configuration:
11
MinHeapFreeRatio = 40
12
MaxHeapFreeRatio = 70
13
MaxHeapSize = 2067791872 (1972.0MB)
14
NewSize = 1310720 (1.25MB)
15
MaxNewSize = 17592186044415 MB
16
OldSize = 5439488 (5.1875MB)
17
NewRatio = 2
18
SurvivorRatio = 8
19
PermSize = 21757952 (20.75MB)
20
MaxPermSize = 85983232 (82.0MB)
21
22
Heap Usage:
23
PS Young Generation
24
Eden Space:
25
capacity = 6422528 (6.125MB)
26
used = 5445552 (5.1932830810546875MB)
27
free = 976976 (0.9317169189453125MB)
28
84.78829520089286% used
29
From Space:
30
capacity = 131072 (0.125MB)
31
used = 98304 (0.09375MB)
32
free = 32768 (0.03125MB)
33
75.0% used
34
To Space:
35
capacity = 131072 (0.125MB)
36
used = 0 (0.0MB)
37
free = 131072 (0.125MB)
38
0.0% used
39
PS Old Generation
40
capacity = 35258368 (33.625MB)
41
used = 4119544 (3.9287033081054688MB)
42
free = 31138824 (29.69629669189453MB)
43
11.683876009235595% used
44
PS Perm Generation
45
capacity = 52428800 (50.0MB)
46
used = 26075168 (24.867218017578125MB)
47
free = 26353632 (25.132781982421875MB)
48
49.73443603515625% used
49
....
使用jmap -histo[:live] pid查看堆内存中的对象数目、大小统计直方图，如果带上live则只统计活对象，如下：
01
root@ubuntu:/# jmap -histo:live 21711 | more
02
03
num #instances #bytes class name
04
----------------------------------------------
05
1: 38445 5597736 <constMethodKlass>
06
2: 38445 5237288 <methodKlass>
07
3: 3500 3749504 <constantPoolKlass>
08
4: 60858 3242600 <symbolKlass>
09
5: 3500 2715264 <instanceKlassKlass>
10
6: 2796 2131424 <constantPoolCacheKlass>
11
7: 5543 1317400 [I
12
8: 13714 1010768 [C
13
9: 4752 1003344 [B
14
10: 1225 639656 <methodDataKlass>
15
11: 14194 454208 java.lang.String
16
12: 3809 396136 java.lang.Class
17
13: 4979 311952 [S
18
14: 5598 287064 [[I
19
15: 3028 266464 java.lang.reflect.Method
20
16: 280 163520 <objArrayKlassKlass>
21
17: 4355 139360 java.util.HashMap$Entry
22
18: 1869 138568 [Ljava.util.HashMap$Entry;
23
19: 2443 97720 java.util.LinkedHashMap$Entry
24
20: 2072 82880 java.lang.ref.SoftReference
25
21: 1807 71528 [Ljava.lang.Object;
26
22: 2206 70592 java.lang.ref.WeakReference
27
23: 934 52304 java.util.LinkedHashMap
28
24: 871 48776 java.beans.MethodDescriptor
29
25: 1442 46144 java.util.concurrent.ConcurrentHashMap$HashEntry
30
26: 804 38592 java.util.HashMap
31
27: 948 37920 java.util.concurrent.ConcurrentHashMap$Segment
32
28: 1621 35696 [Ljava.lang.Class;
33
29: 1313 34880 [Ljava.lang.String;
34
30: 1396 33504 java.util.LinkedList$Entry
35
31: 462 33264 java.lang.reflect.Field
36
32: 1024 32768 java.util.Hashtable$Entry
37
33: 948 31440 [Ljava.util.concurrent.ConcurrentHashMap$HashEntry;
class name是对象类型，说明如下：
1
B byte
2
C char
3
D double
4
F float
5
I int
6
J long
7
Z boolean
8
[ 数组，如[I表示int[]
9
[L+类名 其他对象
还有一个很常用的情况是：用jmap把进程内存使用情况dump到文件中，再用jhat分析查看。jmap进行dump命令格式如下：
1
jmap -dump:format=b,file=dumpFileName
我一样地对上面进程ID为21711进行Dump：
1
root@ubuntu:/# jmap -dump:format=b,file=/tmp/dump.dat 21711
2
Dumping heap to /tmp/dump.dat ...
3
Heap dump file created
dump出来的文件可以用MAT、VisualVM等工具查看，这里用jhat查看：
01
root@ubuntu:/# jhat -port 9998 /tmp/dump.dat
02
Reading from /tmp/dump.dat...
03
Dump file created Tue Jan 28 17:46:14 CST 2014
04
Snapshot read, resolving...
05
Resolving 132207 objects...
06
Chasing references, expect 26 dots..........................
07
Eliminating duplicate references..........................
08
Snapshot resolved.
09
Started HTTP server on port 9998
10
Server is ready.
然后就可以在浏览器中输入主机地址:9998查看了：
转存失败
重新上传
取消
上面红线框出来的部分大家可以自己去摸索下，最后一项支持OQL（对象查询语言）。
D、jstat（JVM统计监测工具）
语法格式如下：
1
jstat [ generalOption | outputOptions vmid [interval[s|ms] [count]] ]
vmid是虚拟机ID，在Linux/Unix系统上一般就是进程ID。interval是采样时间间隔。count是采样数目。比如下面输出的是GC信息，采样时间间隔为250ms，采样数为4：
1
root@ubuntu:/# jstat -gc 21711 250 4
2
S0C S1C S0U S1U EC EU OC OU PC PU YGC YGCT FGC FGCT GCT
3
192.0 192.0 64.0 0.0 6144.0 1854.9 32000.0 4111.6 55296.0 25472.7 702 0.431 3 0.218 0.649
4
192.0 192.0 64.0 0.0 6144.0 1972.2 32000.0 4111.6 55296.0 25472.7 702 0.431 3 0.218 0.649
5
192.0 192.0 64.0 0.0 6144.0 1972.2 32000.0 4111.6 55296.0 25472.7 702 0.431 3 0.218 0.649
6
192.0 192.0 64.0 0.0 6144.0 2109.7 32000.0 4111.6 55296.0 25472.7 702 0.431 3 0.218 0.649
要明白上面各列的意义，先看JVM堆内存布局：
转存失败
重新上传
取消
可以看出：
1
堆内存 = 年轻代 + 年老代 + 永久代
2
年轻代 = Eden区 + 两个Survivor区（From和To）
现在来解释各列含义：
1
S0C、S1C、S0U、S1U：Survivor 0/1区容量（Capacity）和使用量（Used）
2
EC、EU：Eden区容量和使用量
3
OC、OU：年老代容量和使用量
4
PC、PU：永久代容量和使用量
5
YGC、YGT：年轻代GC次数和GC耗时
6
FGC、FGCT：Full GC次数和Full GC耗时
7
GCT：GC总耗时
其他JVM性能调优参考资料：
《Java虚拟机规范》
《Java Performance》
《Trouble Shooting Guide for JavaSE 6 with HotSpot VM》: http://www.oracle.com/technetwork/java/javase/tsg-vm-149989.pdf
《Effective Java》
VisualVM: http://docs.oracle.com/javase/7/docs/technotes/guides/visualvm/
jConsole: http://docs.oracle.com/javase/1.5.0/docs/guide/management/jconsole.html
Monitoring and Managing JavaSE 6 Applications: http://www.oracle.com/technetwork/articles/javase/monitoring-141801.html
原文路径：http://blog.youkuaiyun.com/wisgood/article/details/25343845
对应参数解释：
各种 Java Thread State 第一分析法则
使用 TDA 工具，看到大量 Java Thread State 的第一反应是：
1，线程状态为“waiting for monitor entry”：
意味着它 在等待进入一个临界区 ，所以它在”Entry Set“队列中等待。
此时线程状态一般都是 Blocked：
java.lang.Thread.State: BLOCKED (on object monitor)
2，线程状态为“waiting on condition”：
说明它在等待另一个条件的发生，来把自己唤醒，或者干脆它是调用了 sleep(N)。
此时线程状态大致为以下几种：
java.lang.Thread.State: WAITING (parking)：一直等那个条件发生；
java.lang.Thread.State: TIMED_WAITING (parking或sleeping)：定时的，那个条件不到来，也将定时唤醒自己。
3，如果大量线程在“waiting for monitor entry”：
可能是一个全局锁阻塞住了大量线程。
如果短时间内打印的 thread dump 文件反映，随着时间流逝，waiting for monitor entry 的线程越来越多，没有减少的趋势，可能意味着某些线程在临界区里呆的时间太长了，以至于越来越多新线程迟迟无法进入临界区。
4，如果大量线程在“waiting on condition”：
可能是它们又跑去获取第三方资源，尤其是第三方网络资源，迟迟获取不到Response，导致大量线程进入等待状态。
所以如果你发现有大量的线程都处在 Wait on condition，从线程堆栈看，正等待网络读写，这可能是一个网络瓶颈的征兆，因为网络阻塞导致线程无法执行。
线程状态为“in Object.wait()”：
说明它获得了监视器之后，又调用了 java.lang.Object.wait() 方法。
每个 Monitor在某个时刻，只能被一个线程拥有，该线程就是 “Active Thread”，而其它线程都是 “Waiting Thread”，分别在两个队列 “ Entry Set”和 “Wait Set”里面等候。在 “Entry Set”中等待的线程状态是 “Waiting for monitor entry”，而在 “Wait Set”中等待的线程状态是 “in Object.wait()”。
当线程获得了 Monitor，如果发现线程继续运行的条件没有满足，它则调用对象（一般就是被 synchronized 的对象）的 wait() 方法，放弃了 Monitor，进入 “Wait Set”队列。
此时线程状态大致为以下几种：
java.lang.Thread.State: TIMED_WAITING (on object monitor)；
java.lang.Thread.State: WAITING (on object monitor)；
一般都是RMI相关线程（RMI RenewClean、 GC Daemon、RMI Reaper），GC线程（Finalizer），引用对象垃圾回收线程（Reference Handler）等系统线程处于这种状态。
转存失败
重新上传
取消
图1 A Java Monitor
示范一：
下面这个线程在等待这个锁 0x00000000fe7e3b50，等待进入临界区：
"RMI TCP Connection(64896)-172.16.52.118" daemon prio=10 tid=0x00000000405a6000 nid=0x68fe waiting for monitor entry [0x00007f2be65a3000]
java.lang.Thread.State: BLOCKED (on object monitor)
at com.xyz.goods.service.impl.GoodsServiceImpl.findChanellGoodsCountWithCache(GoodsServiceImpl.java:1734)
- waiting to lock <0x00000000fe7e3b50> (a java.lang.String)
那么谁持有这个锁呢？
是另一个先调用了 findChanellGoodsCountWithCache 函数的线程：
"RMI TCP Connection(64878)-172.16.52.117" daemon prio=10 tid=0x0000000040822000 nid=0x6841 runnable [0x00007f2be76b3000]
java.lang.Thread.State: RUNNABLE
at java.net.SocketInputStream.socketRead0(Native Method)
at java.net.SocketInputStream.read(SocketInputStream.java:129)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read1(BufferedInputStream.java:258)
at java.io.BufferedInputStream.read(BufferedInputStream.java:317)
- locked <0x00000000af4ed638> (a java.io.BufferedInputStream)
at org.bson.io.Bits.readFully(Bits.java:35)
at org.bson.io.Bits.readFully(Bits.java:28)
at com.mongodb.Response.<init>(Response.java:35)
at com.mongodb.DBPort.go(DBPort.java:110)
- locked <0x00000000af442d48> (a com.mongodb.DBPort)
at com.mongodb.DBPort.go(DBPort.java:75)
- locked <0x00000000af442d48> (a com.mongodb.DBPort)
at com.mongodb.DBPort.call(DBPort.java:65)
at com.mongodb.DBTCPConnector.call(DBTCPConnector.java:202)
at com.mongodb.DBApiLayer$MyCollection.__find(DBApiLayer.java:296)
at com.mongodb.DB.command(DB.java:152)
at com.mongodb.DBCollection.getCount(DBCollection.java:760)
at com.mongodb.DBCollection.getCount(DBCollection.java:731)
at com.mongodb.DBCollection.count(DBCollection.java:697)
at com.xyz.goods.manager.MongodbManager.count(MongodbManager.java:202)
at com.xyz.goods.service.impl.GoodsServiceImpl.findChanellGoodsCount(GoodsServiceImpl.java:1787)
at com.xyz.goods.service.impl.GoodsServiceImpl.findChanellGoodsCountWithCache(GoodsServiceImpl.java:1739)
- locked <0x00000000fe7e3b50> (a java.lang.String)
示范二：
等待另一个条件发生来将自己唤醒：
"RMI TCP Connection(idle)" daemon prio=10 tid=0x00007fd50834e800 nid=0x56b2 waiting on condition [0x00007fd4f1a59000]
java.lang.Thread.State: TIMED_WAITING (parking)
at sun.misc.Unsafe.park(Native Method)
- parking to wait for <0x00000000acd84de8> (a java.util.concurrent.SynchronousQueue$TransferStack)
at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:198)
at java.util.concurrent.SynchronousQueue$TransferStack.awaitFulfill(SynchronousQueue.java:424)
at java.util.concurrent.SynchronousQueue$TransferStack.transfer(SynchronousQueue.java:323)
at java.util.concurrent.SynchronousQueue.poll(SynchronousQueue.java:874)
at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:945)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:907)
at java.lang.Thread.run(Thread.java:662)
1）“TIMED_WAITING (parking)”中的 timed_waiting 指等待状态，但这里指定了时间，到达指定的时间后自动退出等待状态；parking指线程处于挂起中。
2）“waiting on condition”需要与堆栈中的“parking to wait for <0x00000000acd84de8> (a java.util.concurrent.SynchronousQueue$TransferStack)” 结合来看。首先，本线程肯定是在等待某个条件的发生，来把自己唤醒。其次，SynchronousQueue 并不是一个队列，只是线程之间移交信息的机制，当我们把一个元素放入到 SynchronousQueue 中时必须有另一个线程正在等待接受移交的任务，因此这就是本线程在等待的条件。
示范三：
"RMI RenewClean-[172.16.50.182:4888]" daemon prio=10 tid=0x0000000040d2c800 nid=0x97e in Object.wait() [0x00007f9ccafd0000]
java.lang.Thread.State: TIMED_WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x0000000799b032d8> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:118)
- locked <0x0000000799b032d8> (a java.lang.ref.ReferenceQueue$Lock)
at sun.rmi.transport.DGCClient$EndpointEntry$RenewCleanThread.run(DGCClient.java:516)
at java.lang.Thread.run(Thread.java:662)
一 linux服务器性能查看
1.1 cpu性能查看
1、查看物理cpu个数：
cat /proc/cpuinfo |grep "physical id"|sort|uniq|wc -l
2、查看每个物理cpu中的core个数：
cat /proc/cpuinfo |grep "cpu cores"|wc -l
3、逻辑cpu的个数：
cat /proc/cpuinfo |grep "processor"|wc -l
物理cpu个数*核数=逻辑cpu个数（不支持超线程技术的情况下）
1.2 内存查看
1、查看内存使用情况：
#free -m
total used free shared buffers cached
Mem: 3949 2519 1430 0 189 1619
-/+ buffers/cache: 710 3239
Swap: 3576 0 3576
total：内存总数
used：已经使用的内存数
free：空闲内存数
shared：多个进程共享的内存总额
- buffers/cache：(已用)的内存数，即used-buffers-cached
+ buffers/cache：(可用)的内存数，即free+buffers+cached
Buffer Cache用于针对磁盘块的读写；
Page Cache用于针对文件inode的读写，这些Cache能有效地缩短I/O系统调用的时间。
对操作系统来说free/used是系统可用/占用的内存；
对应用程序来说-/+ buffers/cache是可用/占用内存,因为buffers/cache很快就会被使用。
我们工作时候应该从应用角度来看。
1.3 硬盘查看
1、查看硬盘及分区信息：
fdisk -l
2、查看文件系统的磁盘空间占用情况：
df -h
3、查看硬盘的I/O性能（每隔一秒显示一次，显示5次）：
iostat -x 1 5
iostat是含在套装systat中的,可以用yum -y install systat来安装。
常关注的参数：
如%util接近100%,说明产生的I/O请求太多，I/O系统已经满负荷，该磁盘可能存在瓶颈。
如idle小于70%，I/O的压力就比较大了，说明读取进程中有较多的wait。
4、查看linux系统中某目录的大小：
du -sh /root
如发现某个分区空间接近用完，可以进入该分区的挂载点，用以下命令找出占用空间最多的文件或目录，然后按照从大到小的顺序，找出系统中占用最多空间的前10个文件或目录：
du -cksh *|sort -rn|head -n 10
1.4 查看平均负载
有时候系统响应很慢，但又找不到原因，这时就要查看平均负载了，看它是否有大量的进程在排队等待。
最简单的命令：
uptime--查看过去的1分钟、5分钟和15分钟内进程队列中的平均进程数量。
还有动态命令top
我们只关心以下部分：
top - 21:33:09 up 1:00, 1 user, load average: 0.00, 0.01, 0.05
如果每个逻辑cpu当前的活动进程不大于3，则系统性能良好；
如果每个逻辑cpu当前的活动进程不大于4，表示可以接受；
如果每个逻辑cpu当前的活动进程大于5，则系统性能问题严重。
一般计算方法：负载值/逻辑cpu个数
还可以结合vmstat命令来判断系统是否繁忙，其中：
procs
r：等待运行的进程数。
b：处在非中断睡眠状态的进程数。
w：被交换出去的可运行的进程数。
memeory
swpd：虚拟内存使用情况，单位为KB。
free：空闲的内存，单位为KB。
buff：被用来作为缓存的内存数，单位为KB。
swap
si：从磁盘交换到内存的交换页数量，单位为KB。
so：从内存交换到磁盘的交换页数量，单位为KB。
io
bi：发送到块设备的块数，单位为KB。
bo：从块设备接受的块数，单位为KB。
system
in：每秒的中断数，包括时钟中断。
cs：每秒的环境切换次数。
cpu
按cpu的总使用百分比来显示。
us：cpu使用时间。
sy：cpu系统使用时间。
id：闲置时间。
1.5 其他参数
查看内核版本号：
uname -a
简化命令：uname -r
查看系统是32位还是64位的：
file /sbin/init
查看发行版：
cat /etc/issue
或lsb_release -a
查看系统已载入的相关模块：
lsmod
查看pci设置：
lspci
二 Linux服务器性能评估
2.1.1 影响Linux服务器性能的因素
1. 操作系统级
CPU
内存
磁盘I/O带宽
网络I/O带宽
2. 程序应用级
2.1.2 系统性能评估标准
影响性能因素
好
坏
糟糕
CPU
user% + sys%< 70%
user% + sys%= 85%
user% + sys% >=90%
内存
Swap In（si）＝0 Swap Out（so）＝0
Per CPU with 10 page/s
More Swap In & Swap Out
磁盘
iowait % < 20%
iowait % =35%
iowait % >= 50%
其中：
%user：表示CPU处在用户模式下的时间百分比。
%sys：表示CPU处在系统模式下的时间百分比。
%iowait：表示CPU等待输入输出完成时间的百分比。
swap in：即si，表示虚拟内存的页导入，即从SWAP DISK交换到RAM
swap out：即so，表示虚拟内存的页导出，即从RAM交换到SWAP DISK
2.1.3 系统性能分析工具
1.常用系统命令
Vmstat、sar、iostat、netstat、free、ps、top等
2.常用组合方式
vmstat、sar、iostat检测是否是CPU瓶颈
free、vmstat检测是否是内存瓶颈
iostat检测是否是磁盘I/O瓶颈
netstat检测是否是网络带宽瓶颈
2.1.4 Linux性能评估与优化
系统整体性能评估（uptime命令）
uptime
16:38:00 up 118 days, 3:01, 5 users,load average: 1.22, 1.02, 0.91
注意：
load average三值大小一般不能大于系统CPU的个数。
系统有8个CPU,如load average三值长期大于8，说明CPU很繁忙，负载很高，可能会影响系统性能。
但偶尔大于8，一般不会影响系统性能。
如load average输出值小于CPU个数，则表示CPU有空闲时间片，比如本例中的输出，CPU是非常空闲的
2.2.1 CPU性能评估
1.利用vmstat命令监控系统CPU
显示系统各种资源之间相关性能简要信息，主要看CPU负载情况。
下面是vmstat命令在某个系统的输出结果：
[root@node1 ~]#vmstat 2 3
procs
———–memory———- —swap– —–io—- –system– —–cpu——
r b swpd freebuff cache si so bi bo incs us sy idwa st
0 0 0 162240 8304 67032 0 0 13 21 1007 23 0 1 98 0 0
0 0 0 162240 8304 67032 0 0 1 0 1010 20 0 1 100 0 0
0 0 0 162240 8304 67032 0 0 1 1 1009 18 0 1 99 0 0
Procs
r--运行和等待cpu时间片的进程数，这个值如果长期大于系统CPU的个数，说明CPU不足，需要增加CPU
b--在等待资源的进程数，比如正在等待I/O、或者内存交换等。
CPU
us
用户进程消耗的CPU 时间百分比。
us的值比较高时，说明用户进程消耗的cpu时间多，但是如果长期大于50%，就需要考虑优化程序或算法。
sy
内核进程消耗的CPU时间百分比。Sy的值较高时，说明内核消耗的CPU资源很多。
根据经验，us+sy的参考值为80%，如果us+sy大于 80%说明可能存在CPU资源不足。
2.利用sar命令监控系统CPU
sar对系统每方面进行单独统计，但会增加系统开销，不过开销可以评估，对系统的统计结果不会有很大影响。
下面是sar命令对某个系统的CPU统计输出：
[root@webserver ~]# sar -u 3 5
Linux
2.6.9-42.ELsmp (webserver) 11/28/2008_i686_
(8 CPU)
11:41:24
AM CPU %user %nice%system
%iowait %steal %idle
11:41:27
AM all 0.88 0.00 0.29 0.00 0.00 98.83
11:41:30
AM all 0.13 0.00 0.17 0.21 0.00 99.50
11:41:33
AM all 0.04 0.00 0.04 0.00 0.00 99.92
11:41:36
AM all 90.08 0.00 0.13 0.16 0.00 9.63
11:41:39
AM all 0.38 0.00 0.17 0.04 0.00 99.41
Average:
all 0.34 0.00 0.16 0.05 0.00 99.45
输出解释如下：
%user列显示了用户进程消耗的CPU 时间百分比。
%nice列显示了运行正常进程所消耗的CPU 时间百分比。
%system列显示了系统进程消耗的CPU时间百分比。
%iowait列显示了IO等待所占用的CPU时间百分比
%steal列显示了在内存相对紧张的环境下pagein强制对不同的页面进行的steal操作 。
%idle列显示了CPU处在空闲状态的时间百分比。
问题
你是否遇到过系统CPU整体利用率不高，而应用缓慢的现象？
在一个多CPU的系统中，如果程序使用了单线程，会出现这么一个现象，CPU的整体使用率不高，但是系统应用却响应缓慢，这可能是由于程序使用单线程的原因，单线程只使用一个CPU，导致这个CPU占用率为100%，无法处理其它请求，而其它的CPU却闲置，这就导致了整体CPU使用率不高，而应用缓慢现象的发生。
2.3.1 内存性能评估
1.利用free指令监控内存
free是监控Linux内存使用状况最常用的指令，看下面的一个输出：
[root@webserver ~]# free -m
total
used freeshared
buffers cached
Mem:
8111 7185 926 0 243 6299
-/+
buffers/cache:
643 7468
Swap:
8189 0 8189
经验公式：
应用程序可用内存/系统物理内存>70%，表示系统内存资源非常充足，不影响系统性能;
应用程序可用内存/系统物理内存<20%，表示系统内存资源紧缺，需要增加系统内存;
20%<应用程序可用内存/系统物理内存<70%，表示系统内存资源基本能满足应用需求，暂时不影响系统性能
2.利用vmstat命令监控内存
[root@node1
~]#
vmstat 2 3
procs
———–memory———- —swap– —–io—- –system– —–cpu——
r b swpd freebuff cache si so bi bo incs us sy idwa st
0 0 0 162240 8304 67032 0 0 13 21 1007 23 0 1 98 0 0
0 0 0 162240 8304 67032 0 0 1 0 1010 20 0 1 100 0 0
0 0 0 162240 8304 67032 0 0 1 1 1009 18 0 1 99 0 0
memory
swpd--切换到内存交换区的内存数量（k为单位)。如swpd值偶尔非0，不影响系统性能
free--当前空闲的物理内存数量（k为单位）
buff--buffers cache的内存数量，一般对块设备的读写才需要缓冲
cache--page cached的内存数量
一般作为文件系统cached，频繁访问的文件都会被cached，如cache值较大，说明cached的文件数较多，如果此时IO中bi比较小，说明文件系统效率比较好。
swap
si--由磁盘调入内存，也就是内存进入内存交换区的数量。
so--由内存调入磁盘，也就是内存交换区进入内存的数量。
si、so的值长期不为0，表示系统内存不足。需增加系统内存。
2.4.1磁盘I/O性能评估
1.磁盘存储基础
频繁访问的文件或数据尽可能用内存读写代替直接磁盘I/O，效率高千倍。
将经常进行读写的文件与长期不变的文件独立出来，分别放置到不同的磁盘设备上。
对于写操作频繁的数据，可以考虑使用裸设备代替文件系统。
裸设备优点：
数据可直接读写，不需经过操作系统级缓存，节省内存资源，避免内存资源争用;
避免文件系统级维护开销，如文件系统需维护超级块、I-node等;
避免了操作系统cache预读功能，减少了I/O请求
使用裸设备的缺点是：
数据管理、空间管理不灵活，需要很专业的人来操作。
2.利用iostat评估磁盘性能
[root@webserver ~]# iostat -d 2 3
Linux
2.6.9-42.ELsmp (webserver) 12/01/2008_i686_
(8 CPU)
Device:
tps Blk_read/sBlk_wrtn/sBlk_read
Blk_wrtn
sda 1.87 2.58 114.12 6479462 286537372
Device:
tps Blk_read/sBlk_wrtn/sBlk_read
Blk_wrtn
sda
0.00 0.00 0.00 0 0
Device:
tps Blk_read/sBlk_wrtn/sBlk_read
Blk_wrtn
sda
1.00 0.00 12.00 0 24
解释如下：
Blk_read/s--每秒读取数据块数
Blk_wrtn/s--每秒写入数据块数
Blk_read--读取的所有块数
Blk_wrtn--写入的所有块数
可通过Blk_read/s和Blk_wrtn/s值对磁盘的读写性能有一个基本的了解.
如Blk_wrtn/s值很大，表示磁盘写操作频繁，考虑优化磁盘或程序，
如Blk_read/s值很大，表示磁盘直接读操作很多，可将读取的数据放入内存
规则遵循：
长期的、超大的数据读写，肯定是不正常的，这种情况一定会影响系统性能。
3.利用sar评估磁盘性能
通过“sar –d”组合，可以对系统的磁盘IO做一个基本的统计，请看下面的一个输出：
[root@webserver ~]# sar -d 2 3
Linux
2.6.9-42.ELsmp (webserver) 11/30/2008_i686_
(8 CPU)
11:09:33
PM DEV tps rd_sec/swr_sec/savgrq-sz
avgqu-sz await svctm %util
11:09:35
PM dev8-0 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00
11:09:35
PM DEV tps rd_sec/swr_sec/savgrq-sz
avgqu-sz await svctm %util
11:09:37
PM dev8-0 1.00 0.00 12.00 12.00 0.00 0.00 0.00 0.00
11:09:37
PM DEV tps rd_sec/swr_sec/savgrq-sz
avgqu-sz await svctm %util
11:09:39
PM dev8-0 1.99 0.00 47.76 24.00 0.00 0.50 0.25 0.05
Average:
DEV tps rd_sec/swr_sec/savgrq-sz
avgqu-sz await svctm %util
Average:
dev8-0 1.00 0.00 19.97 20.00 0.00 0.33 0.17 0.02
参数含义：
await--平均每次设备I/O操作等待时间（毫秒）
svctm--平均每次设备I/O操作的服务时间（毫秒）
%util--一秒中有百分之几的时间用于I/O操作
对磁盘IO性能评判标准：
正常svctm应小于await值，而svctm和磁盘性能有关，CPU、内存负荷也会对svctm值造成影响，过多的请求也会间接的导致svctm值的增加。
await值取决svctm和I/O队列长度以及I/O请求模式，
如果svctm的值与await很接近，表示几乎没有I/O等待，磁盘性能很好，
如果await的值远高于svctm的值，则表示I/O队列等待太长，系统上运行的应用程序将变慢，
此时可以通过更换更快的硬盘来解决问题。
%util--衡量磁盘I/O重要指标，
如%util接近100%，表示磁盘产生的I/O请求太多，I/O系统已经满负荷工作，该磁盘可能存在瓶颈。
可优化程序或者 通过更换 更高、更快的磁盘。
2.5.1. 网络性能评估
（1）通过ping命令检测网络的连通性
（2）通过netstat –i组合检测网络接口状况
（3）通过netstat –r组合检测系统的路由表信息
（4）通过sar –n组合显示系统的网络运行状态
三 Linux服务器性能调优
1.为磁盘I/O调整Linux内核电梯算法
选择文件系统后，该算法可以平衡低延迟需求，收集足够数据，有效组织对磁盘读写请求。
2.禁用不必要的守护进程，节省内存和CPU资源
许多守护进程或服务通常非必需，消耗宝贵内存和CPU时间。将服务器置于险地。
禁用可加快启动时间，释放内存。
减少CPU要处理的进程数
一些应被禁用的Linux守护进程，默认自动运行：
序号 守护进程 描述
1 Apmd 高级电源管理守护进程
2 Nfslock 用于NFS文件锁定
3 Isdn ISDN Moderm支持
4 Autofs 在后台自动挂载文件系统(如自动挂载CD-ROM)
5 Sendmail 邮件传输代理
6 Xfs X Window的字体服务器
3.关掉GUI
4、清理不需要的模块或功能
服务器软件包中太多被启动的功能或模块实际上是不需要的(如Apache中的许多功能模块)，禁用掉有助于提高系统内存可用量，腾出资源给那些真正需要的软件，让它们运行得更快。
5、禁用控制面板
在Linux中，有许多流行的控制面板，如Cpanel，Plesk，Webmin和phpMyAdmin等，禁用释放出大约120MB内存，内存使用量大约下降30-40%。
6、改善Linux Exim服务器性能
使用DNS缓存守护进程，可降低解析DNS记录需要的带宽和CPU时间，DNS缓存通过消除每次都从根节点开始查找DNS记录的需求，从而改善网络性能。
Djbdns是一个非常强大的DNS服务器，它具有DNS缓存功能，Djbdns比BIND DNS服务器更安全，性能更好，可以直接通过http://cr.yp.to/下载，或通过Red Hat提供的软件包获得。
7、使用AES256增强gpg文件加密安全
为提高备份文件或敏感信息安全，许多Linux系统管理员都使用gpg进行加密，在使用gpg时，最好指定gpg使用AES256加密算法，AES256使用256位密钥，它是一个开放的加密算法，美国国家安全局(NSA)使用它保护绝密信息。
8、远程备份服务安全
安全是选择远程备份服务最重要的因素，大多数系统管理员都害怕两件事：(黑客)可以删除备份文件，不能从备份恢复系统。
为了保证备份文件100%的安全，备份服务公司提供远程备份服务器，使用scp脚本或RSYNC通过SSH传输数据，这样，没有人可以直接进入和访问远程系统，因此，也没有人可以从备份服务删除数据。在选择远程备份服务提供商时，最好从多个方面了解其服务强壮性，如果可以，可以亲自测试一下。
9、更新默认内核参数设置
为了顺利和成功运行企业应用程序，如数据库服务器，可能需要更新一些默认的内核参数设置，例如，2.4.x系列内核消息队列参数msgmni有一个默认值(例如，共享内存，或shmmax在Red Hat系统上默认只有33554432字节)，它只允许有限的数据库并发连接，下面为数据库服务器更好地运行提供了一些建议值(来自IBM DB2支持网站)：
kernel.shmmax=268435456 (32位)
kernel.shmmax=1073741824 (64位)
kernel.msgmni=1024
fs.file-max=8192
kernel.sem=”250 32000 32 1024″
10、优化TCP
优化TCP协议有助于提高网络吞吐量，跨广域网的通信使用的带宽越大，延迟时间越长时，建议使用越大的TCP Linux大小，以提高数据传输速率，TCP Linux大小决定了发送主机在没有收到数据传输确认时，可以向接收主机发送多少数据。
11、选择正确的文件系统
使用ext4文件系统取代ext3
● Ext4是ext3文件系统的增强版，扩展了存储限制
●具有日志功能，保证高水平的数据完整性(在非正常关闭事件中)
●非正常关闭和重启时，它不需要检查磁盘(这是一个非常耗时的动作)
●更快的写入速度，ext4日志优化了硬盘磁头动作
12、使用noatime文件系统挂载选项
在文件系统启动配置文件fstab中使用noatime选项，如果使用了外部存储，这个挂载选项可以有效改善性能。
13、调整Linux文件描述符限制
Linux限制了任何进程可以打开的文件描述符数量，默认限制是每进程1024，这些限制可能会阻碍基准测试客户端(如httperf和apachebench)和Web服务器本身获得最佳性能，Apache每个连接使用一个进程，因此不会受到影响，但单进程Web服务器，如Zeus是每连接使用一个文件描述符，因此很容易受默认限制的影响。
打开文件限制是一个可以用ulimit命令调整的限制，ulimit -aS命令显示当前的限制，ulimit -aH命令显示硬限制(在未调整/proc中的内核参数前，你不能增加限制)。
Linux第三方应用程序性能技巧
对于运行在Linux上的第三方应用程序，一样有许多性能优化技巧，这些技巧可以帮助你提高Linux服务器的性能，降低运行成本。
14、正确配置MySQL
为了给MySQL分配更多的内存，可设置MySQL缓存大小，要是MySQL服务器实例使用了更多内存，就减少缓存大小，如果MySQL在请求增多时停滞不动，就增加MySQL缓存。
15、正确配置Apache
检查Apache使用了多少内存，再调整StartServers和MinSpareServers参数，以释放更多的内存，将有助于你节省30-40%的内存。
16、分析Linux服务器性能
提高系统效率最好的办法是找出导致整体速度下降的瓶颈并解决掉，下面是找出系统关键瓶颈的一些基本技巧：
● 当大型应用程序，如OpenOffice和Firefox同时运行时，计算机可能会开始变慢，内存不足的出现几率更高。
● 如果启动时真的很慢，可能是应用程序初次启动需要较长的加载时间，一旦启动好后运行就正常了，否则很可能是硬盘太慢了。
●CPU负载持续很高，内存也够用，但CPU利用率很低，可以使用CPU负载分析工具监控负载时间。
17、学习5个Linux性能命令
使用几个命令就可以管理Linux系统的性能了，下面列出了5个最常用的Linux性能命令，包括
top、vmstat、iostat、free和sar，它们有助于系统管理员快速解决性能问题。
(1)top
当前内核服务的任务，还显示许多主机状态的统计数据，默认情况下，它每隔5秒自动更新一次。
如：当前正常运行时间，系统负载，进程数量和内存使用率，
此外，这个命令也显示了那些使用最多CPU时间的进程(包括每个进程的各种信息，如运行用户，执行的命令等)。
(2)vmstat
Vmstat命令提供当前CPU、IO、进程和内存使用率的快照，它和top命令类似，自动更新数据，如：
$ vmstat 10
(3)iostat
Iostat提供三个报告：CPU利用率、设备利用率和网络文件系统利用率，使用-c，-d和-h参数可以分别独立显示这三个报告。
(4)free
显示主内存和交换空间内存统计数据，指定-t参数显示总内存，指定-b参数按字节为单位，使用-m则以兆为单位，默认情况下千字节为单位。
Free命令也可以使用-s参数加一个延迟时间(单位：秒)连续运行，如：
$ free -s 5
(5)sar
收集，查看和记录性能数据，这个命令比前面几个命令历史更悠久，它可以收集和显示较长周期的数据。
其它
下面是一些归类为其它的性能技巧：
18、将日志文件转移到内存中
当一台机器处于运行中时，最好是将系统日志放在内存中，当系统关闭时再将其复制到硬盘，当你运行一台开启了syslog功能的笔记本电脑或移动设备时，ramlog可以帮助你提高系统电池或移动设备闪存驱动器的寿命，使用ramlog的一个好处是，不用再担心某个守护进程每隔30秒向syslog发送一条消息，放在以前，硬盘必须随时保持运转，这样对硬盘和电池都不好。
19、先打包，后写入
在内存中划分出固定大小的空间保存日志文件，这意味着笔记本电脑硬盘不用一直保持运转，只有当某个守护进程需要写入日志时才运转，注意ramlog使用的内存空间大小是固定的，否则系统内存会很快被用光，如果笔记本使用固态硬盘，可以分配50-80MB内存给ramlog使用，ramlog可以减少许多写入周期，极大地提高固态硬盘的使用寿命。
20、一般调优技巧
尽可能使用静态内容替代动态内容，如果你在生成天气预告，或其它每隔1小时就必须更新的数据，最好是写一个程序，每隔1小时生成一个静态的文件，而不是让用户运行一个CGI动态地生成报告。
为动态应用程序选择最快最合适的API，CGI可能最容易编程，但它会为每个请求产生一个进程，通常，这是一个成本很高，且不必要的过程，FastCGI是更好的选择，和Apache的mod_perl一样，都可以极大地提高应用程序的性能。
种一棵树，最好的时间是十年前，其次是现在。
vi /etc/sysctl.conf
fs.file-max = 999999
net.ipv4.tcp_fin_timeout = 30
net.ipv4.conf.default.rp_filter = 1
net.ipv4.conf.all.rp_filter = 1
net.ipv4.tcp_syncookies = 0
net.ipv6.conf.all.disable_ipv6 = 1
net.ipv4.tcp_synack_retries = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_timestamps = 0
net.ipv4.tcp_keepalive_time = 300
net.core.netdev_max_backlog = 8096
net.ipv4.ip_local_port_range = 1024 65500
net.ipv4.tcp_window_scaling = 1
net.ipv4.tcp_max_syn_backlog = 3240000
net.core.somaxconn = 65535
net.ipv4.tcp_max_tw_buckets = 6000
net.ipv4.tcp_max_orphans = 262144
net.core.rmem_default = 8388608
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216
net.ipv4.tcp_congestion_control = cubic
sysctl -p
nginx.conf配置：
user root;
worker_rlimit_nofile 409600;
worker_processes 8;
error_log logs/error.log;
events {
use epoll;
worker_connections 204800;
multi_accept on;
accept_mutex off;
}
http {
include mime.types;
default_type application/octet-stream;
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'$upstream_addr $upstream_response_time $request_time '
'"$http_user_agent" "$http_x_forwarded_for"';
#access_log logs/access.log main;
#access_log off;
#error_log logs/error.log crit;
sendfile on;
tcp_nopush on;
server_tokens off;
tcp_nodelay on;
keepalive_timeout 300;
keepalive_requests 200000;
client_body_timeout 3;
client_header_timeout 3;
send_timeout 3;
gzip on;
gzip_min_length 1k;
gzip_http_version 1.0;
gzip_buffers 30 64k;
gzip_comp_level 9;
gzip_proxied expired no-cache no-store private auth;
gzip_types text/plain text/css text/javascript application/json application/x-javascript text/xml application/xml;
gzip_vary on;
proxy_temp_path /tmp/temp_dir;
proxy_cache_path /tmp/cache levels=1:2 keys_zone=cache_one:10m inactive=1d max_size=1500M;
upstream test2 {
sticky;
server 19.14.132.94:80 max_fails=2 fail_timeout=3s;
server 19.14.132.95:80 max_fails=2 fail_timeout=3s;
server 19.14.132.96:80 max_fails=2 fail_timeout=3s;
keepalive 2000;
}
upstream test1 {
sticky;
server 19.14.132.91:9001;
server 19.14.132.93:9001;
check interval=3000 rise=2 fall=3 timeout=30000 type=http;
check_http_send "GET / HTTP/1.0\r\nconnection: keep-alive\r\n\r\n";
check_http_expect_alive http_2xx http_3xx http_4xx;
}
server {
listen 80 reuseport;
server_name localhost;
charset utf-8;
client_max_body_size 30m;
client_body_buffer_size 2048k;
proxy_connect_timeout 30;
proxy_send_timeout 3;
proxy_read_timeout 3;
proxy_buffer_size 64k;
proxy_buffers 12 64k;
proxy_busy_buffers_size 64k;
proxy_temp_file_write_size 128k;
proxy_max_temp_file_size 30m;
proxy_intercept_errors off;
proxy_ignore_client_abort on;
add_header X-Cache $upstream_cache_status;
location ~* "\.(jpg|jpeg|png|gif|html|css|js)$" {
proxy_pass http://test2;
proxy_redirect off;
proxy_set_header Host $host;
proxy_cache cache_one;
proxy_cache_valid 200 302 1h;
proxy_cache_valid 301 1d;
proxy_cache_valid any 1d;
expires 1d;
}
location / {
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_set_header X-NginX-Proxy true;
proxy_set_header Connection "";
proxy_set_header X-Forwarded-Server $host;
proxy_set_header X-Forwarded-Host $host;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_pass http://test2;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}
}
773
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
