下面是小编整理的Java性能调优工具（共含7篇），希望能帮助到大家!同时，但愿您也能像本文投稿人“酩酩叽”一样，积极向本站投稿分享好文章。
1.1、jps命令
jps用于列出Java的进程，jps可以增加参数，-m用于输出传递给Java进程的参数，-l用于输出主函数的完整路径，-v可以用于显示传递给jvm的参数，
jps -l -m -v
31427 sun.tools.jps.Jps -l -m -v -Dapplication.home=/Library/Java/JavaVirtualMachines/jdk1.7.0_55.jdk/Contents/Home -Xms8m
1.2、jstat命令
jstat是一个可以用于观察Java应用程序运行时信息的工具，它的功能非常强大，可以通过它查看堆信息的详细情况，它的基本使用方法为：
jstat - [-t] [-h]
选项option可以由以下值组成：
jstat -class pid:显示加载class的数量，及所占空间等信息。
jstat -compiler pid:显示VM实时编译的数量等信息。
jstat -gc pid:可以显示gc的信息，查看gc的次数，及时间。其中最后五项，分别是young gc的次数，young gc的时间，full gc的次数，full gc的时间，gc的总时间。
jstat -gccapacity:可以显示，VM内存中三代（young,old,perm）对象的使用和占用大小，如：PGCMN显示的是最小perm的内存使用量，PGCMX显示的是perm的内存最大使用量，PGC是当前新生成的perm内存占用量，PC是但前perm内存占用量。其他的可以根据这个类推， OC是old内纯的占用量。
jstat -gcnew pid:new对象的信息。
jstat -gcnewcapacity pid:new对象的信息及其占用量。
jstat -gcold pid:old对象的信息。
jstat -gcoldcapacity pid:old对象的信息及其占用量。
jstat -gcpermcapacity pid: perm对象的信息及其占用量。
jstat -gcutil pid:统计gc信息统计。
jstat -printcompilation pid:当前VM执行的信息。
除了以上一个参数外，还可以同时加上 两个数字，如：jstat -printcompilation 3024 250 6是每250毫秒打印一次，一共打印6次。
这些参数中最常用的参数是gcutil，下面是该参数的输出介绍以及一个简单例子：
S0 — Heap上的 Survivor space 0 区已使用空间的百分比
S1 — Heap上的 Survivor space 1 区已使用空间的百分比
E — Heap上的 Eden space 区已使用空间的百分比
O — Heap上的 Old space 区已使用空间的百分比
P — Perm space 区已使用空间的百分比
YGC — 从应用程序启动到采样时发生 Young GC 的次数
YGCT– 从应用程序启动到采样时 Young GC 所用的时间(单位秒)
FGC — 从应用程序启动到采样时发生 Full GC 的次数
FGCT– 从应用程序启动到采样时 Full GC 所用的时间(单位秒)
GCT — 从应用程序启动到采样时用于垃圾回收的总时间(单位秒)
实例使用1：
[root@localhost bin]# jstat -gcutil 25444
S0 S1 E O P YGC YGCT FGC FGCT GCT
11.63 0.00 56.46 66.92 98.49 162 0.248 6 0.331 0.579
1.3、jinfo命令
jinfo可以用来查看正在运行的Java应用程序的扩展参数，甚至在运行时修改部分参数，它的基本语法为：
1
jinfo
jinfo可以查看运行时参数：
jinfo -flag MaxTenuringThreshold 31518
-XX:MaxTenuringThreshold=15
jinfo还可以在运行时修改参数值：
>jinfo -flag PrintGCDetails 31518
-XX:-PrintGCDetails
>jinfo -flag +PrintGCDetails 31518
>jinfo -flag PrintGCDetails 31518
-XX:+PrintGCDetails
1.4、jmap命令
jmap命令主要用于生成堆快照文件，它的使用方法如下：
>jmap -dump:format=b,file=heap.hprof 31531
Dumping heap to /Users/caojie/heap.hprof ...
Heap dump file created
获得堆快照文件之后，我们可以使用多种工具对文件进行分析，例如jhat，visual vm等。
1.5、jhat命令
使用jhat工具可以分析Java应用程序的堆快照文件，使用命令如下：
>jhat heap.hprof
Reading from heap.hprof...
Dump file created Tue Nov 11 06:02:05 CST
Snapshot read, resolving...
Resolving 8781 objects...
Chasing references, expect 1 dots.
Eliminating duplicate references.
Snapshot resolved.
Started HTTP server on port 7000
Server is ready.
jhat在分析完成之后，使用HTTP服务器展示其分析结果，在浏览器中访问127.0.0.1:7000/即可得到分析结果。
1.6、jstack命令
jstack可用于导出Java应用程序的线程堆栈信息，语法为：
1
jstack -l
jstack可以检测死锁，下例通过一个简单例子演示jstack检测死锁的功能。java代码如下：
public class DeadLock extends Thread {
protected Object myDirect;
static ReentrantLock south = new ReentrantLock;
static ReentrantLock north = new ReentrantLock();
public DeadLock(Object obj) {
this.myDirect = obj;
if (myDirect == south) {
this.setName(“south”);
}
if (myDirect == north) {
this.setName(“north”);
}
}
@Override
public void run() {
if (myDirect == south) {
try {
north.lockInterruptibly();
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
south.lockInterruptibly();
System.out.println(“car to south has passed”);
} catch (InterruptedException e1) {
System.out.println(“car to south is killed”);
} finally {
if (north.isHeldByCurrentThread())
north.unlock();
if (south.isHeldByCurrentThread())
south.unlock();
}
}
if (myDirect == north) {
try {
south.lockInterruptibly();
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
north.lockInterruptibly();
System.out.println(“car to north has passed”);
} catch (InterruptedException e1) {
System.out.println(“car to north is killed”);
} finally {
if (north.isHeldByCurrentThread())
north.unlock();
if (south.isHeldByCurrentThread())
south.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
DeadLock car2south = new DeadLock(south);
DeadLock car2north = new DeadLock(north);
car2south.start();
car2north.start();
Thread.sleep(1000);
}
}
使用jps命令查看进程号为32627，然后使用jstack -l 32637 >a.txt命令把堆栈信息打印到文件中，该文件内容如下：
2014-11-11 21:33:12
Full thread dump Java HotSpot(TM) 64-Bit Server VM (24.55-b03 mixed mode):
“Attach Listener” daemon prio=5 tid=0x00007f8d0c803000 nid=0x3307 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
“DestroyJavaVM” prio=5 tid=0x00007f8d0b80b000 nid=0x1903 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
“north” prio=5 tid=0x00007f8d0c075000 nid=0x5103 waiting on condition [0x0000000115b06000]
java.lang.Thread.State: WAITING (parking)
at sun.misc.Unsafe.park(Native Method)
- parking to wait for <0x00000007d55ab600>(a java.util.concurrent.locks.ReentrantLock$NonfairSync)
at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:834)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:894)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1221)
at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:340)
at DeadLock.run(DeadLock.java:48)
Locked ownable synchronizers:
- <0x00000007d55ab5d0>(a java.util.concurrent.locks.ReentrantLock$NonfairSync)
“south” prio=5 tid=0x00007f8d0c074800 nid=0x4f03 waiting on condition [0x0000000115a03000]
java.lang.Thread.State: WAITING (parking)
at sun.misc.Unsafe.park(Native Method)
- parking to wait for <0x00000007d55ab5d0>(a java.util.concurrent.locks.ReentrantLock$NonfairSync)
at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:834)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:894)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1221)
at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:340)
at DeadLock.run(DeadLock.java:28)
Locked ownable synchronizers:
- <0x00000007d55ab600>(a java.util.concurrent.locks.ReentrantLock$NonfairSync)
“Service Thread” daemon prio=5 tid=0x00007f8d0c025800 nid=0x4b03 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
“C2 CompilerThread1” daemon prio=5 tid=0x00007f8d0c025000 nid=0x4903 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
“C2 CompilerThread0” daemon prio=5 tid=0x00007f8d0d01b000 nid=0x4703 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
“Signal Dispatcher” daemon prio=5 tid=0x00007f8d0c02 nid=0x4503 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
Locked ownable synchronizers:
- None
“Finalizer” daemon prio=5 tid=0x00007f8d0d004000 nid=0x3103 in Object.wait() [0x000000011526a000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000007d5505568>(a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)
- locked <0x00000007d5505568>(a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)
at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:189)
Locked ownable synchronizers:
- None
“Reference Handler” daemon prio=5 tid=0x00007f8d0d001800 nid=0x2f03 in Object.wait() [0x0000000115167000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000007d55050f0>(a java.lang.ref.Reference$Lock)
at java.lang.Object.wait(Object.java:503)
at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)
- locked <0x00000007d55050f0>(a java.lang.ref.Reference$Lock)
Locked ownable synchronizers:
- None
“VM Thread” prio=5 tid=0x00007f8d0b83b000 nid=0x2d03 runnable
“GC task thread#0 (ParallelGC)” prio=5 tid=0x00007f8d0b818000 nid=0x2503 runnable
“GC task thread#1 (ParallelGC)” prio=5 tid=0x00007f8d0b819000 nid=0x2703 runnable
“GC task thread#2 (ParallelGC)” prio=5 tid=0x00007f8d0d000000 nid=0x2903 runnable
“GC task thread#3 (ParallelGC)” prio=5 tid=0x00007f8d0d001000 nid=0x2b03 runnable
“VM Periodic Task Thread” prio=5 tid=0x00007f8d0c02e800 nid=0x4d03 waiting on condition
JNI global references: 109
Found one Java-level deadlock:
=============================
“north”:
waiting for ownable synchronizer 0x00000007d55ab600, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
which is held by “south”
“south”:
waiting for ownable synchronizer 0x00000007d55ab5d0, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
which is held by “north”
Java stack information for the threads listed above:
===================================================
“north”:
at sun.misc.Unsafe.park(Native Method)
- parking to wait for <0x00000007d55ab600>(a java.util.concurrent.locks.ReentrantLock$NonfairSync)
at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:834)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:894)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1221)
at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:340)
at DeadLock.run(DeadLock.java:48)
“south”:
at sun.misc.Unsafe.park(Native Method)
- parking to wait for <0x00000007d55ab5d0>(a java.util.concurrent.locks.ReentrantLock$NonfairSync)
at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:834)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:894)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1221)
at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:340)
at DeadLock.run(DeadLock.java:28)
Found 1 deadlock.
从这个输出可以知道：
1、在输出的最后一段，有明确的“Found one Java-level deadlock”输出，所以通过jstack命令我们可以检测死锁；
2、输出中包含了所有线程，除了我们的north,sorth线程外，还有“Attach Listener”, “C2 CompilerThread0”, “C2 CompilerThread1”等等；
3、每个线程下面都会输出当前状态，以及这个线程当前持有锁以及等待锁，当持有与等待造成循环等待时，将导致死锁，
1.7、jstatd命令
jstatd命令是一个RMI服务器程序，它的作用相当于代理服务器，建立本地计算机与远程监控工具的通信，jstatd服务器能够将本机的Java应用程序信息传递到远程计算机，由于需要多台计算机做演示，此处略。
1.8、hprof工具
hprof工具可以用于监控Java应用程序在运行时的CPU信息和堆信息，关于hprof的官方文档如下：docs.oracle.com/javase/7/docs/technotes/samples/hprof.html
2、Visual VM工具
Visual VM是一个功能强大的多合一故障诊断和性能监控的可视化工具，它集成了多种性能统计工具的功能，使用Visual VM可以替代jstat、jmap、jhat、jstack等工具。在命令行输入jvisualvm即可启动visualvm。
打开Visual VM之后，左边导航栏会显示出当前机器所有Java进程：
点击你想监控的程序即可对该程序进行监控，Visual VM的性能监控页一共有以下几个tab页：
概述页会显示程序的基本使用情况，比如，进程ID，系统属性，启动参数等。
通过监视页面，可以监视应用程序的CPU、堆、永久区、类加载器和线程数的整体情况，通过页面上的Perform. GC和Heap Dump按钮还可以手动执行Full GC和生成堆快照。
线程页面会提供详细的线程信息，单击Thread Dump按钮可以导出当前所有线程的堆栈信息，如果Visual VM在当前线程中找到死锁，则会以十分显眼的方式在Threads页面给予提示。
抽样器可以对CPU和内存两个性能进行抽样，用于实时地监控程序。CPU采样器可以将CPU占用时间定位到方法，内存采样器可以查看当前程序的堆信息。下面是一个频繁调用的Java程序，我们会对改程序进行采样：
public class MethodTime {
static java.util.Random r=new java.util.Random();
static Map
static{
map=new HashMap
map.put(“1”, “Java”);
map.put(“2”, “C++”);
map.put(“3”, “Delphi”);
map.put(“4”, “C”);
map.put(“5”, “Phython”);
}
public String getNameById(String id){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
return map.get(id);
}
public List
List
String[] strs=ids.split(“,”);
for(String id:strs){
re.add(getNameById(id));
}
return re;
}
public List
List
String[] strs=ids.split(“,”);
for(String id:strs){
//A bad code
getNameById(id);
re.add(getNameById(id));
}
return re;
}
public class NamesByIdsThread implements Runnable{
@Override
public void run() {
try{
while(true){
int c=r.nextInt(4);
String ids=“”;
for(int i=0;i
ids=Integer.toString((r.nextInt(4)+1))+“,”;
getNamesByIds(ids);
}
}catch(Exception e){
}
}
}
public class NamesByIdsBadThread implements Runnable{
@Override
public void run() {
try{
while(true){
int c=r.nextInt(4);
String ids=“”;
for(int i=0;i
ids=Integer.toString((r.nextInt(4)+1))+“,”;
getNamesByIdsBad(ids);
}
}catch(Exception e){
}
}
}
public static void main(String args[]){
MethodTime instance=new MethodTime();
new Thread(instance.new NamesByIdsThread()).start();
new Thread(instance.new NamesByIdsBadThread()).start();
}
}
通过Visual VM的采样功能，可以找到改程序中占用CPU时间最长的方法：
默认Visual VM不统计内置对象的函数调用，比如java.*包中的类，如果要统计这些内置对象，单机右上角的设置进行调配。Visual VM虽然可以统计方法的调用时间，但是无法给出方法调用堆栈，Jprofile不仅可以给出方法调用时间，还可以给出方法调用堆栈，较Visual VM更强大。
右击左导航的应用程序，会出现以下菜单：
单机应用程序快照，可以分析当前应用程序的快照，单击堆Dump能够对当前的堆信息进行分析。Visual VM的更多使用方法，可以查看Oracle的官方文档docs.oracle.com/javase/7/docs/technotes/guides/visualvm/
BTrace插件
BTrace是一款功能强大的性能检测工具，它可以在不停机的情况下，通过字节码注入，动态监控系统的运行情况，它可以跟踪指定的方法调用、构造函数调用和系统内存等信息，本部分打算举一个例子，讲解一下BTrace的使用。要在Visual VM中使用Btrace，首先需要安装Btrace插件，点击工具->插件即可在线安装，安装后右键应用程序，就会出现如下选项：
点击Trace application，即可进入BTrace插件界面。使用BTrace可以监控指定函数的耗时，以下脚本通过正则表达式，监控所有类的getNameById方法：
import com.sun.btrace.annotations.*;
import static com.sun.btrace.BTraceUtils.*;
@BTrace
public class TracingScript. {
@TLS
private static long startTime = 0;
@OnMethod(clazz=“/.+/”, method=“/getNameById/”)//监控任意类的getNameById方法
public static void startMethod() {
startTime=timeMillis();
}
@OnMethod(clazz=“/.+/”, method=“/getNameById/”,
location=@Location(Kind.RETURN))//方法返回时触发
public static void endMethod() {
print(strcat(strcat(name(probeClass()), “.”), probeMethod()));
print(“ [”);
print(strcat(“Time taken : ”, str(timeMillis() - startTime)));
println(“]”);
}
}
点击运行，部分输出如下：
MethodTime.getNameById [Time taken : 5]
MethodTime.getNameById [Time taken : 4]
MethodTime.getNameById [Time taken : 7]
MethodTime.getNameById [Time taken : 7]
BTrace除了可以监控函数耗时外，还可以指定程序运行到某一行代码触发某一行为，定时触发行为，监控函数参数等等。
3、MAT内存分析工具
MAT是一款功能强大的Java堆内存分析器，可以用于查找内存泄露以及查看内存消耗情况，MAT的官方文档如下：help.eclipse.org/luna/index.jsp?topic=/org.eclipse.mat.ui.help/welcome.html。
在MAT中有浅堆和深堆的概念，浅堆是指一个对象结构所占用的内存大小，深堆是指一个对象被GC回收后可以真正释放的内存大小。
通过MAT，可以列出所有垃圾回收的根对象，Java系统的根对象可能是以下类：系统类，线程，Java局部变量，本地栈等等。在MAT中还可以很清楚的看到根对象到当前对象的引用关系链。
MAT还可以自动检测内存泄露，单击菜单上的Leak Suspects命令，MAT会自动生成一份报告，这份报告罗列了系统内可能存在内存泄露的问题点。
在MAT中，还可以自动查找并显示消耗内存最多的几个对象，这些消耗大量内存的大对象往往是解决系统性能问题的关键所在。
具体例子，略，网速太慢，至今还未下好。。
性能是苹果审核的一个很重要的部分，CPU，内存，图形绘制，存储空间和网络性能都是应用的重要的评估和组成部分，不管是作为个人应用开发者还是企业的开发人员，都需要遵循的一个原则是站在用户的角度去思考问题，比如说常见的适配问题，不能因为不同的机型导致最终出现的UI效果差异很大，用户在使用的过程的中最好不要表现出明显的卡顿现象，或者更严重的是出现App闪退，出现闪退的结果就是应用被删，这是属于比较严重的问题。Instruments是目前最强大的性能调试工具之一，有助于我们解决应用存在的性能问题。Instruments是里面包括了内存管理工作，I/O以及网络过去，本文主要讲述的是Allocation和Time Profle。
Allocations（内存分配）
就是动态的将文字输出在视图上，下面贴出代码你会发现开始还好运行到慢的简直跟蜗牛有的一拼，不要运行太久，否则内存不够用，代码如下:
@implementation FETextView- (id)initWithFrame.:(CGRect)frame. text:(NSString *)text { self = [super initWithFrame.:frame]; if (self) { [NSTimer scheduledTimerWithTimeInterval:0.01 target:self selector:@selector(appendNextCharacter) userInfo:nil repeats:YES]; _text = [text copy]; self.backgroundColor = [UIColor whiteColor]; } return self;}//原文地址www.2cto.com- (void)appendNextCharacter { for (NSUInteger i = 0; i <= self.index; i++) { if (i < self.text.length) {UILabel *label = [[UILabel alloc] init];label.text = [self.text substringWithRange:NSMakeRange(i,1)];label.opaque = NO;[label sizeToFit];CGRect frame. = label.frame;frame.origin = [self originAtIndex:i fontSize:label.font.pointSize];label.frame=frame;[self addSubview:label]; } } self.index++;}- (CGPoint)originAtIndex:(NSUInteger)index fontSize:(CGFloat)fontSize { if (index == 0) { return CGPointZero; } else { CGPoint rigin = [self originAtIndex:index-1 fontSize:fontSize]; NSString * prevCharacter = [self.text substringWithRange:NSMakeRange(index-1,1)]; CGSize prevCharacterSize = [prevCharacter sizeWithAttributes:@{ NSFontAttributeName: [UIFont systemFontOfSize:fontSize] }]; origin.x += prevCharacterSize.width; if (origin.x >CGRectGetWidth(self.bounds)) {origin.x = 0;origin.y += prevCharacterSize.height; } return origin; }}@end
主视图控制器的调用代码:
NSString *path = [[NSBundle mainBundle] pathForResource:@“FlyElephant” ofType:@“txt”];FETextView *textView = [[FETextView alloc] initWithFrame.:CGRectMake(0, 64, CGRectGetWidth(self.view.bounds), CGRectGetHeight(self.view.bounds)) text:[NSString stringWithContentsOfFile:pathencoding:NSUTF8StringEncoding error:nil]];[self.view addSubview:textView];
总结
优化标准的 Red Hat 系统并不难，也不费时；您只需理解组成该分发版的底层组件并利用 Linux 的本身的配置功能来优化那些组件，
本教程主要讲述了以下四个方面的内容：
安装问题
删除、安装和更新程序软件包
为提高硬件性能和软件性能而优化系统
构建定制的内核的所需步骤
参考资料
由于 Red Hat 已经很流行，所以在 Web 上有大量关于这些主题的信息：性能调优、分区选择、文件系统选择、一般的系统管理和构建定制的内核。以下是一些参考资料，供您浏览。当您在为看上去难以理解的问题寻找答案的时候，别忘了 Google 的功能。
仅和 Red Hat 有关的信息：
当然，Red Hat Web 站点有关于 Red Hat 的所有信息。该站点有产品资源和支持文档、该公司支持的邮件列表、Red Hat 勘误表页面和当前硬件兼容性列表。
Securing and Optimizing Linux (Red Hat Edition - A Hands on Guide) 是一个开放源代码、在线书项目，作者是 Gerhard Mourani。其中一些内容有点过时，但是多数概念在多个版本发布中都有用。
Linux 文档编制计划（Linux Documentation Project，LDP）
Linux 文档编制计划是全面提供一般 Linux 文档的最佳站点之一，恰巧的是，该计划接受了 Red Hat 的大量赞助。LDP 包括成千上万的实用指南、指南和常见问题解答，甚至还有一个可搜索的手册页列表。如果您在这里找不到所需的信息，那么这些信息一定还没被写出来。
更多参考资料
内核源代码和文档
Linux 内核源代码被存储在 kernel.org，
索引页面的上部是所有的当前内核列表（开发和稳定），还有所有重要的 changelog 文档的链接，这些 changelog 包含每个内核发布中的更新和错误修正的详细信息。
Kerneltrap.org 是关于 Linux 内核的最新信息的来源。
Kernel Cousins 被描述为“试图跟踪各种开发者邮件列表的活动。通过总结进行的讨论，所提供的信息要比一般的新闻服务所提供的信息更为详细。”
如果您想了解关于内核编译的详细信息，请参阅全面的内核实用指南。
文件系统信息
如果您想了解当前文件系统的更多信息，请访问以下各支持 Web 站点：
在 developerWorks，您可以找到 JFS for Linux 的白皮书、常见问题解答、手册页、实用程序、源代码和安装文档。
您可以在 namesys.com 找到 ReiserFS 文件系统 的类似参考资料。
到处都有 EXT3 文件系统的信息。Red Hat 写了 EXT3 的白皮书，Daniel Robbins 写了两篇有关 EXT3 的 developerWorks 文章，写得不错；第一篇是 Introducing ext3，第二篇是 Surprises in ext3。
Daniel 的 Advanced filesystem implementor's guide 是一本讲述文件系统问题和选择的好书，建议您从第 1 部分开始阅读并读完全书（总共是 11 部分）。
其它参考资料
请了解另一种安装 Red Hat 软件包的方法。
如果您想了解 Qt 和 KDE 的有关信息，请访问 kde.org 的 Qt 和 KDE 邮件列表。
请访问 samba.org，了解有关 Samba 的各种参考资料。另外，请访问 developerWorks，阅读 Daniel Robbins 的 Samba 系列：第 1 部分是关于基本概念；第 2 部分是关于设置；第 3 部分是关于配置。
您的反馈
我们期待着您对本教程的反馈。您也可以通过 tom@syroidmanor.com 直接与作者联系。
您对这篇文章的看法如何？
我们都知道单进程、异步IO应该可以获得最优通讯性能，但现实里我们常常发现这种模式常常达不到预期的效果。
这可能是由于网卡在和你的应用程序抢CPU。
cat /proc/interrupts 看看你的网卡是几号中断，都在哪个CPU上工作？通常你的网卡应该工作在CPU0上面。（如果不是，可以把它绑到CPU0上面去）
cat cat /proc/cpuinfo看看你有几个CPU，是多少核的。假设是双CPU*四核，
ps x | grep your_app 看看你的程序的pid是多少。假设pid是5678。
ok，试试下面的魔法：
taskset -p 10 5678
如果你的程序是单线程异步io的，你可能会发现你的程序处理能力提高了30%以上。而且程序的性能数据不会再漂浮不定，总是稳定在最优值。
为什么会这样？因为我们把网卡和应用程序的负载分布到不同的物理CPU上了。各得其所，不切换就没有各种运算代价。
Ps: 最近地球流行redis、memcached、nginx什么的，他们都是异步io的，可以试试这个优化方法。
作者 21aspnet
在一个大型的数据库中，性能成为人们关注的焦点之一，如何让数据库高效有效的运行成为广大数据库管理人员和开发人员必须要考虑的问题，性能是一个应用或多个应用在相同的环境下运行时对效率的衡量。性能常用响应时间和工作效率来表示。响应时间是指完成一个任务花费的时间，可以从以下三方面来减少响应时间：
· 减少竞争和等待的次数，尤其是磁盘读写等待次数
· 利用更快的部件
· 减少利用资源所需的时间
绝大多数性能的获得来自于优秀的数据库设计、精确的查询分析和适当的索引。最好性能的获得能够通过确立优秀的数据库设计，在开发时学会使用SQL Server查询优化器来实现。
为了取得更好的数据库性能，我们就需要对数据库进行优化，减少系统资源的竞争，如对数据cache，过程cache，系统资源和CPU的竞争。
在SQL Server中，有如下优化层次：
·应用层——大部分性能的获得来自于对你的SQL应用中查询的优化，这必须是以好的数据库设计为基础的。
·数据库层——应用共享在数据库层中的资源，这些资源包括硬盘，事务日志和数据cache。
·服务器层——在服务器层有许多共享的资源，包括数据高速缓存，过程高速缓存，锁，CPU等。
·设备层——指的是存储数据的磁盘及其控制器，在这一层，你应尤其关注磁盘的I/O。
·网络层——指连接用户和SQL Server的网络。
·硬件层——指可利用的CPU。
·操作系统层——理想地，SQL Server是一台机器的唯一主要应用，它必须和操作系统以及其他sybase软件，如Backup Server或SQL Server Monitor共享处理器、内存以及其他资源。
在大多数情况下面，我们是对应用层进行优化，，因为对应用性能的优化是大家最乐于接受的功能，其结果能被观测及检验，查询的性能是SQL应用的整个性能的一个关键。
应用层上的问题包括以下内容：
·决策支持VS.和在线事务处理(OLTP)需要不同的性能策略
·事务设计能够减少并发，因为长的事务保持占用锁，也就减少了其他用户对相关数据的存取
·关联一致性对数据修改需要join操作
·支持Select操作的索引增加了修改数据的时间
·为了安全而设立的审计限制了性能
在应用层优化的选项包括：
·远程处理或复制处理能够把决策支持从OLTP机器中分离出来
·利用存储过程来减少编译时间和网络的利用
·利用最少量的锁去满足你的应用需要
数据库层的问题包括：
·建立备份和恢复方案
·在设备上分布存储数据
·审计操作影响性能;仅审计你所需的
·日常的维护活动将导致性能的降低和导致用户不能操作数据库表
在数据库层上优化选择包括：
·利用事务日志的阀值来自动转储事务日志防止其超出使用空间
·在数据段中用阀值来监视空间的使用
·利用分区来加速数据的装入
·对象的定位以避免硬盘的竞争
·把重要表和索引放入cache中，保证随时取得
服务器层的问题有：
·应用的类型——服务器是支持OLTP还是DSS，或者两者都支持
·所支持的用户数影响优化决策——随着用户数的增加，对资源的竞争会发生改变
关 键 字：MYSQL
设计1个应用系统似乎并不难，但是要想使系统达到最优化的性能并不是一件容易的事，在开发工具、数据库设计、应用程序的结构、查询设计、接口选择等方面有多种选择，这取决于特定的应用需求以及开发队伍的技能。本文以SQL Server为例，从后台数据库的角度讨论应用程序性能优化技巧，并且给出了一些有益的建议。
1 数据库设计
要在良好的SQL Server方案中实现最优的性能，最关键的是要有1个很好的数据库设计方案。在实际工作中，许多SQL Server方案往往是由于数据库设计得不好导致性能很差。所以，要实现良好的数据库设计就必须考虑这些问题。
1.1 逻辑库规范化问题
一般来说，逻辑数据库设计会满足规范化的前3级标准：
1.第1规范：没有重复的组或多值的列。
2.第2规范：每个非关键字段必须依赖于主关键字，不能依赖于1个组合式主关键字的某些组成部分。
3.第3规范：1个非关键字段不能依赖于另1个非关键字段。
遵守这些规则的设计会产生较少的列和更多的表，因而也就减少了数据冗余，也减少了用于存储数据的页。但表关系也许需要通过复杂的合并来处理，这样会降低系统的性能。某种程度上的非规范化可以改善系统的性能，非规范化过程可以根据性能方面不同的考虑用多种不同的方法进行，但以下方法经实践验证往往能提高性能。
1.如果规范化设计产生了许多4路或更多路合并关系，就可以考虑在数据库实体(表)中加入重复属性(列)。
2.常用的计算字段(如总计、最大值等)可以考虑存储到数据库实体中。
比如某一个项目的计划管理系统中有计划表，其字段为：项目编号、年初计划、二次计划、调整计划、补列计划…，而计划总数(年初计划+二次计划+调整计划+补列计划)是用户经常需要在查询和报表中用到的，在表的记录量很大时，有必要把计划总数作为1个独立的字段加入到表中。这里可以采用触发器以在客户端保持数据的一致性。
3.重新定义实体以减少外部属性数据或行数据的开支。相应的非规范化类型是：
(1)把1个实体(表)分割成2个表(把所有的属性分成2组)。这样就把频繁被访问的数据同较少被访问的数据分开了。这种方法要求在每个表中复制首要关键字。这样产生的设计有利于并行处理，并将产生列数较少的表。
(2)把1个实体(表)分割成2个表(把所有的行分成2组)。这种方法适用于那些将包含大量数据的实体(表)。在应用中常要保留历史记录，但是历史记录很少用到。因此可以把频繁被访问的数据同较少被访问的历史数据分开。而且如果数据行是作为子集被逻辑工作组(部门、销售分区、地理区域等)访问的，那么这种方法也是很有好处的。
1.2 生成物理数据库
要想正确选择基本物理实现策略，必须懂得数据库访问格式和硬件资源的操作特点，主要是内存和磁盘子系统I/O。这是一个范围广泛的话题，但以下的准则可能会有所帮助。
1.与每个表列相关的数据类型应该反映数据所需的最小存储空间，特别是对于被索引的列更是如此。比如能使用smallint类型就不要用integer类型，这样索引字段可以被更快地读取，而且可以在1个数据页上放置更多的数据行，因而也就减少了I/O操作。
2.把1个表放在某个物理设备上，再通过SQL Server段把它的不分簇索引放在1个不同的物理设备上，这样能提高性能。尤其是系统采用了多个智能型磁盘控制器和数据分离技术的情况下，这样做的好处更加明显。
3.用SQL Server段把一个频繁使用的大表分割开，并放在2个单独的智能型磁盘控制器的数据库设备上，这样也可以提高性能。因为有多个磁头在查找，所以数据分离也能提高性能。
4.用SQL Server段把文本或图像列的数据存放在1个单独的物理设备上可以提高性能。1个专用的智能型的控制器能进一步提高性能。
2 与SQL Server相关的硬件系统
与SQL Server有关的硬件设计包括系统处理器、内存、磁盘子系统和网络，这4个部分基本上构成了硬件平台，Windows NT和SQL Server运行于其上。
2.1 系统处理器(CPU)
根据自己的具体需要确定CPU结构的过程就是估计在硬件平台上占用CPU的工作量的过程
关 键 字：MYSQL
查询速度慢的原因很多，常见如下几种：
1、没有索引或者没有用到索引(这是查询慢最常见的问题，是程序设计的缺陷)
2、I/O吞吐量小，形成了瓶颈效应，
3、没有创建计算列导致查询不优化。
4、内存不足
5、网络速度慢
6、查询出的数据量过大（可以采用多次查询，其他的方法降低数据量）
7、锁或者死锁(这也是查询慢最常见的问题，是程序设计的缺陷)
8、sp_lock,sp_who,活动的用户查看,原因是读写竞争资源。
9、返回了不必要的行和列
10、查询语句不好，没有优化
可以通过如下方法来优化查询 :
1、把数据、日志、索引放到不同的I/O设备上，增加读取速度，以前可以将Tempdb应放在RAID0上，SQL2000不在支持。数据量（尺寸）越大，提高I/O越重要.
2、纵向、横向分割表，减少表的尺寸(sp_spaceuse)
3、升级硬件
4、根据查询条件,建立索引,优化索引、优化访问方式，限制结果集的数据量。注意填充因子要适当（最好是使用默认值0）。索引应该尽量小，使用字节数小的列建索引好（参照索引的创建）,不要对有限的几个值的字段建单一索引如性别字段
5、提高网速;
6、扩大服务器的内存,Windows 2000和SQL server 2000能支持4-8G的内存。配置虚拟内存：虚拟内存大小应基于计算机上并发运行的服务进行配置。运行 Microsoft SQL Server? 2000 时，可考虑将虚拟内存大小设置为计算机中安装的物理内存的 1.5 倍。如果另外安装了全文检索功能，并打算运行 Microsoft 搜索服务以便执行全文索引和查询，可考虑：将虚拟内存大小配置为至少是计算机中安装的物理内存的 3 倍。将 SQL Server max server memory 服务器配置选项配置为物理内存的 1.5 倍（虚拟内存大小设置的一半）。
7、增加服务器CPU个数;但是必须明白并行处理串行处理更需要资源例如内存。使用并行还是串行程是MsSQL自动评估选择的。单个任务分解成多个任务，就可以在处理器上运行。例如耽搁查询的排序、连接、扫描和GROUP BY字句同时执行，SQL SERVER根据系统的负载情况决定最优的并行等级，复杂的需要消耗大量的CPU的查询最适合并行处理。但是更新操作UPDATE,INSERT，DELETE还不能并行处理。
8、如果是使用like进行查询的话，简单的使用index是不行的，但是全文索引，耗空间。 like 'a%' 使用索引 like '%a' 不使用索引用 like '%a%' 查询时，查询耗时和字段值总长度成正比,所以不能用CHAR类型，而是VARCHAR。对于字段的值很长的建全文索引。
9、DB Server 和APPLication Server 分离；OLTP和OLAP分离
10、分布式分区视图可用于实现数据库服务器联合体。联合体是一组分开管理的服务器，但它们相互协作分担系统的处理负荷。这种通过分区数据形成数据库服务器联合体的机制能够扩大一组服务器，以支持大型的多层 Web 站点的处理需要。有关更多信息，参见设计联合数据库服务器。（参照SQL帮助文件'分区视图'）
a、在实现分区视图之前，必须先水平分区表
b、在创建成员表后，在每个成员服务器上定义一个分布式分区视图，并且每个视图具有相同的名称。这样，引用分布式分区视图名的查询可以在任何一个成员服务器上运行。系统操作如同每个成员服务器上都有一个原始表的复本一样，但其实每个服务器上只有一个成员表和一个分布式分区视图。数据的位置对应用程序是透明的。
11、重建索引 DBCC REINDEX ,DBCC INDEXDEFRAG,收缩数据和日志 DBCC SHRINKDB,DBCC SHRINKFILE. 设置自动收缩日志.对于大的数据库不要设置数据库自动增长，它会降低服务器的性能。 在T-sql的写法上有很大的讲究，下面列出常见的要点：首先，DBMS处理查询计划的过程是这样的：
1、查询语句的词法
关 键 字：MYSQL
★ java个人简历
★ java年终总结
★ 性能的造句
★ 性能的近义词
★ 汽车工具使用方法
★ 课件制作工具
★ 工具采购申请报告
★ 扫描工具详谈
