师门技术论坛：java运行的程序占用哪些资源如何合理使用

引子：

也许你听过这样一句话，java程序是很吃内存的.

        仔细思考这句话为什么呢？

首先我们分析，java程序的运行需要什么资源？如何优化呢？

1．java程序的运行需要什么资源？

答：占据着CPU和内存空间

2．如何优化？

2.1java代码优化

1.    避免在循环条件中使用复杂表达式 
在不做编译优化的情况下，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。 
例子： 

importjava.util.vector;

class cel {

   void method (vector vector) {

       for (int i = 0; i < vector.size ();i++)  // violation

           ; // ...

   }

}
更正： 

class cel_fixed {

   void method (vector vector) {

       int size = vector.size ()

       for (int i = 0; i < size; i++)

           ; // ...

   }

}

此外：在多重循环中，如果有可能，尽量将最长的循环放在最内层，最短的循环放在最外层，以减少循环层间的变换次数。
2. 尽量避免随意使用静态变量
　　要知道，当某个对象被定义为stataic变量所引用，那么gc通常是不会回收这个对象所占有的内存，如
Java代码
public class A{
static B b = new B();
}
　　此时静态变量b的生命周期与A类同步，如果A类不会卸载，那么b对象会常驻内存，直到程序终止。

3. 尽量避免过多过常的创建Java对象
　　尽量避免在经常调用的方法，循环中new对象，由于系统不仅要花费时间来创建对象，而且还要花时间对这些对象进行垃圾回收和处理，在我们可以控制的范围内，最大限度的重用对象，最好能用基本的数据类型或数组来替代对象。

 

4.尽量使用基本数据类型代替对象
String str = "hello";
　　上面这种方式会创建一个"hello"字符串，而且JVM的字符缓存池还会缓存这个字符串;
String str = new String("hello");
　　此时程序除创建字符串外，str所引用的String对象底层还包含一个char[]数组，这个char[]数组依次存放了h,e,l,l,o
5. 尽量避免不必要的创建
　　如
A a = new A();
if(i==1){list.add(a);}
　　应该改为
if(i==1){
A a = new A();
list.add(a);}

6.尽量在finally块中释放资源
　　程序中使用到的资源应当被释放，以避免资源泄漏。这最好在finally块中去做。不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。

7.尽量缓存经常使用的对象
　　尽可能将经常使用的对象进行缓存，可以使用数组，或HashMap的容器来进行缓存，但这种方式可能导致系统占用过多的缓存，性能下降，推荐可以使用一些第三方的开源工具，如EhCache,Oscache或者使用freemakeer进行缓存，他们基本都实现了FIFO/FLU等缓存算法。

8.如果if判断中多个条件用'||'或者'&&'连接，请将出现频率最高的条件放在表达式最前面。
　　这个小技巧往往能有效的提高程序的性能，尤其是当if判断放在循环体里面时，效果更明显。

9.使用池的概念：数据库连接池和线程池

10.最好通过Class.forname()动态的装载类

11.尽量使用移位来代替'a/b'的操作
"/"是一个代价很高的操作，使用移位的操作将会更快和更有效
　　如
int num = a / 4;
int num = a / 8;
　　应该改为
int num = a 》 2;
int num = a 》 3;
12. 尽量使用局部变量
　　调用方法时传递的参数以及在调用中创建的临时变量都保存在栈(Stack)中，速度较快。其他变量，如静态变量、实例变量等，都在堆(Heap)中创建，速度较慢。
13. 尽量使用StringBuilder和StringBuffer进行字符串连接

14.尽量早释放无用对象的引用
　　大部分时，方法局部引用变量所引用的对象会随着方法结束而变成垃圾，因此，大部分时候程序无需将局部，引用变量显式设为null.
　　例如：
Java代码
Public void test(){
Object obj = new Object();
……
Obj=null;
}
　　上面这个就没必要了，随着方法test()的执行完成，程序中obj引用变量的作用域就结束了。但是如果是改成下面：
Java代码
Public void test(){
Object obj = new Object();
……
Obj=null;
//执行耗时，耗内存操作;或调用耗时，耗内存的方法
……
}
　　这时候就有必要将obj赋值为null,可以尽早的释放对Object对象的引用。


15. 尽量使用System.arraycopy()代替通过来循环复制数组
System.arraycopy() 要比通过循环来复制数组快的多。详解：http://blog.csdn.net/ochangwen/article/details/50587937

16. 慎用异常
　　当创建一个异常时，需要收集一个栈跟踪(stack track)，这个栈跟踪用于描述异常是在何处创建的。构建这些栈跟踪时需要为运行时栈做一份快照，正是这一部分开销很大。当需要创建一个 Exception 时，JVM不得不说：先别动，我想就您现在的样子存一份快照，所以暂时停止入栈和出栈操作。栈跟踪不只包含运行时栈中的一两个元素，而是包含这个栈中的每一个元素。
　　如果您创建一个 Exception ,就得付出代价。好在捕获异常开销不大，因此可以使用 try-catch 将核心内容包起来。从技术上讲，您甚至可以随意地抛出异常，而不用花费很大的代价。招致性能损失的并不是 throw操作--尽管在没有预先创建异常的情况下就抛出异常是有点不寻常。真正要花代价的是创建异常。幸运的是，好的编程习惯已教会我们，不应该不管三七二十一就抛出异常。异常是为异常的情况而设计的，使用时也应该牢记这一原则。

      (1)用Boolean.valueOf(boolean b)代替new Boolean()

包装类的内存占用是很恐怖的，它是基本类型内存占用的N倍(N>2)，同时new一个对象也是性能的消耗。
　　我们再看看JDK对于Boolean.valueOf(booleanb)的实现：
Boolean类提供了两个常量：
Java代码
public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = newBoolean(false);

　　而valueOf(boolean b)的内部实现是：
Java代码
return (b ? TRUE : FALSE);
　　因此用Boolean.valueOf(boolean b)代替new Boolean()既能节省空间，又能提高性能。

(2) 用Integer.valueOf(inti)代替new Integer()
　　和Boolean类似，java开发中使用Integer封装int的场合也非常多，并且通常用int表示的数值都非常小。SUN SDK中对Integer的实例化进行了优化，Integer类缓存了-128到127这256个状态的Integer,如果使用Integer.valueOf(int i)，传入的int范围正好在此内，就返回静态实例。这样如果我们使用Integer.valueOf代替newInteger的话也将大大降低内存的占用。
17.当做数组拷贝操作时，采用System.arraycopy()方法完成拷贝操作要比采用循环的办法完成数组拷贝操作效率高
18. 如果预知长度，就设置ArrayList的长度。

2.2javaweb优化策略：

简单地来看一个浏览器用户访问的流程：浏览器->服务器->返回结果显示 
这么简单地看，可能想得到的优化手段很少，但是细分开来看每一个步骤：

1浏览器发起一个请求，如果本地有缓存会请求本地缓存文件，没有缓存会请求服务器。所以这里就有一个优化点：需要把常用的css和js文件独立成独立的静态文件，一次加载以后，后面直接加载本地缓存。另外IE浏览器内核在请求图片下载时会限制一次只能同时从同一个域名下载两个文件，这里又有优化点，分散图片存储的域名。使用静态文件，减少计算的同时增加本地缓存的使用，减少请求。静态化是常见的一种优化手段。

2 浏览器真实发起请求服务器时，首先被请求到的是服务器的操作系统层，那么服务器的操作系统对外界连接的响应能力，就是你需要了解的东西了。比如linux的内核参数的调整如何影响最大连接数，简单的一个例子就是在一个默认最大文件句柄数只有1024的服务器上，超过这个压力的时候，你如何优化你的程序，也都没有意义。入口只有那么窄，你得把口给扩开。熟悉服务器的性能，调优系统内核也是一个必要的手段。

3 系统层再把连接交给你的server做处理的时候，server的配置这个时候也相当重要。比如apache的最大连接数，tomcat的最大连接数。对server的配置调优很影响性能。比如tomcat在处理静态文件上的能力比apache要差很多，所以在apache+tomcat的负载均衡就能很好地进行动静请求的分离，提高响应速度。又比如tomcat新版本里的NIO技术又比普通IO性能好上不少。对server的了解，要保持跟踪最新动态。

4 server再把数据交给你的程序处理的时候，就到了考验你编程能力的时候了。你得对你的程序的执行效率非常清楚。必须保证每个响应都在尽量短的时间内执行成功。还有比较常见的一些对不常更新的数据使用内存缓存来加快访问。内存永远是最快的。这方面的优化也有非常非常多的事情可以去做，而且跟你的编程息息相关。

5 程序处理的时候，数据库连接池的使用，连接池大小的配置，连接池性能的优化，sql语句的优化，等等都可能影响你的程序的效率，这些地方永远是值得关注的。当然，优秀的算法在这个地方是少不了的。一个好的业务逻辑设计，可能极大提升你的程序性能。对数据库操作的调优也是一个永远的话题。

6 数据传递到数据库进行保存和查询的时候，你就必须对你的数据库的使用有所了解，知道数据库本身的哪些配置可以优化从而带来性能的提升。一个简单的例子就是在内存足够大的时候，增大mysql的内存缓存就可以极大提升它的响应速度。

7 现在server把数据返回给用户了，那么返回的数据的大小又同样影响着结果的显示速度。尽量减小数据的大小，比如开启apache的gzip就能极大压缩常见的静态文件，可以保证用户更快完出数据的下载，同时节省你的服务器使用带宽，老板一定会很高兴的。

8 ajax技术也是在减少大请求，使用更小的局部数据更新来代替整个页面的刷新，加快用户的响应速度，结合静态化能完美改善性能。

一些细节：
1.:禁止servlet和JSP自动重载(auto-reloading)Servlet/JSP提供了一个实用的技术，即自动重载技术，它为开发人员提供了一个好的开发环境，当你改变servlet和JSP页面后而不必重启应用服务器。然而，这种技术在产品运行阶段对系统的资源是一个极大的损耗，因为它会给JSP引擎的类装载器(classloader)带来极大的负担。因此关闭自动重载功能对系统性能的提升是一个极大的帮助。

server.xml中有个选项autoDeploy，改为false，
再看看context中reloadable是否设为true了（应该设置为false，默认是false）。

2.:不要滥用HttpSession　　在很多应用中，我们的程序需要保持客户端的状态，以便页面之间可以相互联系。但不幸的是由于HTTP具有天生无状态性，从而无法保存客户端的状态。因此一般的应用服务器都提供了session来保存客户的状态。在JSP应用服务器中，是通过HttpSession对像来实现session的功能的，但在方便的同时，它也给系统带来了不小的负担。因为每当你获得或更新session时，系统者要对它进行费时的序列化操作。你可以通过对HttpSession的以下几种处理方式来提升系统的性能：　　如果没有必要，就应该关闭JSP页面中对HttpSession的缺省设置：如果你没有明确指定的话，每个JSP页面都会缺省地创建一个HttpSession。如果你的JSP中不需要使用session的话，那可以通过如下的JSP页面指示符来禁止它：＜%@ page session="false"%＞　　不要在HttpSession中存放大的数据对像：如果你在HttpSession中存放大的数据对像的话，每当对它进行读写时，应用服务器都将对其进行序列化，从而增加了系统的额外负担。你在HttpSession中存放的数据对像越大，那系统的性能就下降得越快。　　当你不需要HttpSession时，尽快地释放它：当你不再需要session时，你可以通过调用HttpSession.invalidate()方法来释放它。　　尽量将session的超时时间设得短一点：在JSP应用服务器中，有一个缺省的session的超时时间。当客户在这个时间之后没有进行任何操作的话，系统会将相关的session自动从内存中释放。超时时间设得越大，系统的性能就会越低，因此最好的方法就是尽量使得它的值保持在一个较低的水平。

3.:将页面输出进行压缩　　压缩是解决数据冗余的一个好的方法，特别是在网络带宽不够发达的今天。有的浏览器支持gzip(GNU zip)进行来对HTML文件进行压缩，这种方法可以戏剧性地减少HTML文件的下载时间。因此，如果你将servlet或JSP页面生成的HTML页面进行压缩的话，那用户就会觉得页面浏览速度会非常快。但不幸的是，不是所有的浏览器都支持gzip压缩，但你可以通过在你的程序中检查客户的浏览器是否支持它。下面就是关于这种方法实现的一个代码片段：public void doGet(HttpServletRequest request,HttpServletResponse response)throws IOException, ServletException{OutputStream out = nullString encoding = request.getHeader("Accept-Encoding");if (encoding != null &&encoding.indexOf("gzip") != -1){request.setHeader("Content-Encoding", "gzip");out =new GZIPOutputStream(request.getOutputStream());}else if (encoding != null &&encoding.indexOf("compress") != -1){request.setHeader("Content-Encoding", "compress");out =new ZIPOutputStream(request.getOutputStream());}else{out = request.getOutputStream();}............}

4.:使用线程池　　应用服务器缺省地为每个不同的客户端请求创建一个线程进行处理，并为它们分派service()方法，当service()方法调用完成后，与之相应的线程也随之撤消。由于创建和撤消线程会耗费一定的系统资源，这种缺省模式降低了系统的性能。但所幸的是我们可以通过创建一个线程池来改变这种状况。另外，我们还要为这个线程池设置一个最小线程数和一个最大线程数。在应用服务器启动时，它会创建数量等于最小线程数的一个线程池，当客户有请求时，相应地从池从取出一个线程来进行处理，当处理完成后，再将线程重新放入到池中。如果池中的线程不够地话，系统会自动地增加池中线程的数量，但总量不能超过最大线程数。通过使用线程池，当客户端请求急剧增加时，系统的负载就会呈现的平滑的上升曲线，从而提高的系统的可伸缩性。

5.:选择正确的页面包含机制　　在JSP中有两种方法可以用来包含另一个页面：1、使用include指示符(＜%@includee file=”test.jsp” %＞)。2、使用jsp指示符(＜jsp:includeepage=”test.jsp” flush=”true”/＞)。在实际中我发现，如果使用第一种方法的话，可以使得系统性能更高。

6.:正确地确定javabean的生命周期　　JSP的一个强大的地方就是对javabean的支持。通过在JSP页面中使用＜jsp:useBean＞标签，可以将javabean直接插入到一个JSP页面中。它的使用方法如下：＜jsp:useBean id="name"scope="page|request|session|application"class="package.className" type="typeName"＞＜/jsp:useBean＞　

　其中scope属性指出了这个bean的生命周期。缺省的生命周期为page。如果你没有正确地选择bean的生命周期的话，它将影响系统的性能。　　举例来说，如果你只想在一次请求中使用某个bean，但你却将这个bean的生命周期设置成了session，那当这次请求结束后，这个bean将仍然保留在内存中，除非session超时或用户关闭浏览器。这样会耗费一定的内存，并无谓的增加了JVM垃圾收集器的工作量。因此为bean设置正确的生命周期，并在bean的使命结束后尽快地清理它们，会使用系统性能有一个提高。

7.ServletOutputStream与 PrintWriter的权衡:使用PrintWriter可能会带来一些小的开销，因为它将所有的原始输出都转换为字符流来输出，因此如果使用它来作为页面输出的话，系统要负担一个转换过程。而使用ServletOutputStream作为页面输出的话就不存在一个问题，但它是以二进制进行输出的。因此在实际应用中要权衡两者的利弊。

等等。。。

2.3数据库优化策略

总体上分两种，1.sql语句的优化2.数据库服务器优化，这里讨论sql语句优化

1. count的优化

比如：计算id大于5的城市

a. select count(*) from world.city where id > 5;

b. select (select count(*) from world.city) – count(*) fromworld.city where id <= 5;

a语句当行数超过11行的时候需要扫描的行数比b语句要多， b语句扫描了6行，此种情况下，b语句比a语句更有效率。当没有where语句的时候直接select count(*) from world.city这样会更快，因为mysql总是知道表的行数。

2. 避免使用不兼容的数据类型。

例如float和int、char和varchar、binary和varbinary是不兼容的。数据类型的不兼容可能使优化器无法执行一些本来可以进行的优化操作。

在程序中，保证在实现功能的基础上，尽量减少对数据库的访问次数；通过搜索参数，尽量减少对表的访问行数,最小化结果集，从而减轻网络负担；能够分开的操作尽量分开处理，提高每次的响应速度；在数据窗口使用SQL时，尽量把使用的索引放在选择的首列；算法的结构尽量简单；在查询时，不要过多地使用通配符如 SELECT* FROM T1语句，要用到几列就选择几列如：SELECTCOL1,COL2 FROM T1；在可能的情况下尽量限制尽量结果集行数如：SELECTTOP 300 COL1,COL2,COL3 FROM T1,因为某些情况下用户是不需要那么多的数据的。不要在应用中使用数据库游标，游标是非常有用的工具，但比使用常规的、面向集的SQL语句需要更大的开销；按照特定顺序提取数据的查找。

3. 索引字段上进行运算会使索引失效。

尽量避免在WHERE子句中对字段进行函数或表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如：

SELECT * FROM T1 WHERE F1/2=100 应改为: SELECT* FROM T1 WHERE F1=100*2

4. 避免使用!=或＜＞、IS NULL或IS NOT NULL、IN，NOT IN等这样的操作符.

因为这会使系统无法使用索引,而只能直接搜索表中的数据。例如: SELECT id FROM employee WHERE id !=“B%”优化器将无法通过索引来确定将要命中的行数,因此需要搜索该表的所有行。在in语句中能用exists语句代替的就用exists.

5. 尽量使用数字型字段.

一部分开发人员和数据库管理人员喜欢把包含数值信息的字段

设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接回逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。

6. 合理使用EXISTS,NOTEXISTS子句。如下所示：

1.SELECT SUM(T1.C1) FROM T1 WHERE (SELECT COUNT(*)FROM T2 WHERET2.C2=T1.C2>0)

2.SELECT SUM(T1.C1) FROM T1WHERE EXISTS(SELECT * FROM T2 WHERET2.C2=T1.C2)

两者产生相同的结果，但是后者的效率显然要高于前者。因为后者不会产生大量锁定的表扫描或是索引扫描。如果你想校验表里是否存在某条纪录，不要用count(*)那样效率很低，而且浪费服务器资源。可以用EXISTS代替。如：

IF (SELECT COUNT(*) FROM table_name WHERE column_name =‘xxx’)可以写成：IF EXISTS (SELECT * FROM table_name WHERE column_name = ‘xxx’)

7. 能够用BETWEEN的就不要用IN

8. 能够用DISTINCT的就不用GROUP BY

9. 尽量不要用SELECTINTO语句。SELECTINTO语句会导致表锁定，阻止其他用户访问该表。

10. 必要时强制查询优化器使用某个索引

SELECT * FROM T1 WHERE nextprocess = 1 AND processid IN (8,32,45)改成：

SELECT * FROM T1 (INDEX = IX_ProcessID) WHERE nextprocess = 1 ANDprocessid IN (8,32,45)

则查询优化器将会强行利用索引IX_ProcessID执行查询。

11. 消除对大型表行数据的顺序存取

尽管在所有的检查列上都有索引，但某些形式的WHERE子句强迫优化器使用顺序存取。如：

SELECT * FROM orders WHERE (customer_num=104 ANDorder_num>1001) OR order_num=1008

解决办法可以使用并集来避免顺序存取：

SELECT * FROM orders WHERE customer_num=104 AND order_num>1001UNION SELECT * FROM orders WHERE order_num=1008

这样就能利用索引路径处理查询。【jacking数据结果集很多，但查询条件限定后结果集不大的情况下，后面的语句快】

12. 尽量避免在索引过的字符数据中，使用非打头字母搜索。这也使得引擎无法利用索引。

见如下例子：

SELECT * FROM T1 WHERE NAME LIKE ‘%L%’

SELECT * FROM T1 WHERE SUBSTING(NAME,2,1)=’L’

SELECT * FROM T1 WHERE NAME LIKE ‘L%’

即使NAME字段建有索引，前两个查询依然无法利用索引完成加快操作，引擎不得不对全表所有数据逐条操作来完成任务。而第三个查询能够使用索引来加快操作，不要习惯性的使用‘%L%’这种方式(会导致全表扫描)，如果可以使用`L%’相对来说更好;

13. 虽然UPDATE、DELETE语句的写法基本固定，但是还是对UPDATE语句给点建议：

a) 尽量不要修改主键字段。

b) 当修改VARCHAR型字段时，尽量使用相同长度内容的值代替。

c) 尽量最小化对于含有UPDATE触发器的表的UPDATE操作。

d) 避免UPDATE将要复制到其他数据库的列。

e) 避免UPDATE建有很多索引的列。

f) 避免UPDATE在WHERE子句条件中的列。

14. 能用UNION ALL就不要用UNION

UNION ALL不执行SELECTDISTINCT函数，这样就会减少很多不必要的资源

在跨多个不同的数据库时使用UNION是一个有趣的优化方法，UNION从两个互不关联的表中返回数据，这就意味着不会出现重复的行，同时也必须对数据进行排序，我们知道排序是非常耗费资源的，特别是对大表的排序。

UNION ALL可以大大加快速度，如果你已经知道你的数据不会包括重复行，或者你不在乎是否会出现重复的行，在这两种情况下使用UNIONALL更适合。此外，还可以在应用程序逻辑中采用某些方法避免出现重复的行，这样UNIONALL和UNION返回的结果都是一样的，但UNIONALL不会进行排序。

15. 字段数据类型优化：

a. 避免使用NULL类型：NULL对于大多数数据库都需要特殊处理，MySQL也不例外，它需要更多的代码，更多的检查和特殊的索引逻辑，有些开发人员完全没有意识到，创建表时NULL是默认值，但大多数时候应该使用NOT NULL，或者使用一个特殊的值，如0，-1作为默认值。

b. 尽可能使用更小的字段，MySQL从磁盘读取数据后是存储到内存中的，然后使用cpu周期和磁盘I/O读取它，这意味着越小的数据类型占用的空间越小，从磁盘读或打包到内存的效率都更好，但也不要太过执着减小数据类型，要是以后应用程序发生什么变化就没有空间了。修改表将需要重构，间接地可能引起代码的改变，这是很头疼的问题，因此需要找到一个平衡点。

c. 优先使用定长型

16. 关于大数据量limit分布的优化见下面链接（当偏移量特别大时，limit效率会非常低）：

http://ariyue.iteye.com/blog/553541

附上一个提高limit效率的简单技巧，在覆盖索引(覆盖索引用通俗的话讲就是在select的时候只用去读取索引而取得数据，无需进行二次select相关表)上进行偏移，而不是对全行数据进行偏移。可以将从覆盖索引上提取出来的数据和全行数据进行联接，然后取得需要的列，会更有效率，看看下面的查询：

mysql> select film_id, description from sakila.film order bytitle limit 50, 5;

如果表非常大，这个查询最好写成下面的样子：

mysql> select film.film_id, film.description from sakila.film

inner join(select film_id from sakila.film order by title liimit50,5) as film usinig(film_id);

17. 程序中如果一次性对同一个表插入多条数据，比如以下语句：

insert into person(name,age) values(‘xboy’, 14);

insert into person(name,age) values(‘xgirl’, 15);

insert into person(name,age) values(‘nia’, 19);

把它拼成一条语句执行效率会更高.

insert into person(name,age) values(‘xboy’, 14), (‘xgirl’,15),(‘nia’, 19);

18. 不要在选择的栏位上放置索引，这是无意义的。应该在条件选择的语句上合理的放置索引，比如where，order by。

SELECT id,title,content,cat_id FROM article WHERE cat_id = 1;

上面这个语句，你在id/title/content上放置索引是毫无意义的，对这个语句没有任何优化作用。但是如果你在外键cat_id上放置一个索引，那作用就相当大了。

19. ORDER BY语句的MySQL优化：

a. ORDER BY + LIMIT组合的索引优化。如果一个SQL语句形如：

SELECT [column1],[column2],…. FROM [TABLE] ORDER BY [sort] LIMIT[offset],[LIMIT];

这个SQL语句优化比较简单，在[sort]这个栏位上建立索引即可。

b. WHERE + ORDER BY + LIMIT组合的索引优化，形如：

SELECT [column1],[column2],…. FROM [TABLE] WHERE [columnX] =[VALUE] ORDER BY [sort] LIMIT [offset],[LIMIT];

这个语句，如果你仍然采用第一个例子中建立索引的方法，虽然可以用到索引，但是效率不高。更高效的方法是建立一个联合索引(columnX,sort)

c. WHERE + IN + ORDER BY + LIMIT组合的索引优化，形如：

SELECT [column1],[column2],…. FROM [TABLE] WHERE [columnX] IN([value1],[value2],…) ORDER BY [sort] LIMIT [offset],[LIMIT];

这个语句如果你采用第二个例子中建立索引的方法，会得不到预期的效果（仅在[sort]上是using index，WHERE那里是using where;using filesort），理由是这里对应columnX的值对应多个。

目前哥还木有找到比较优秀的办法，等待高手指教。

d.WHERE+ORDER BY多个栏位+LIMIT，比如:

SELECT * FROM [table] WHERE uid=1 ORDER x,y LIMIT 0,10;

对于这个语句，大家可能是加一个这样的索引:(x,y,uid)。但实际上更好的效果是(uid,x,y)。这是由MySQL处理排序的机制造成的。

20. 其它技巧：

http://www.cnblogs.com/nokiaguy/archive/2008/05/24/1206469.html

http://www.cnblogs.com/suchshow/archive/2011/12/15/2289182.html

http://www.cnblogs.com/cy163/archive/2009/05/28/1491473.html

http://www.cnblogs.com/younggun/articles/1719943.html

http://wenku.baidu.com/view/f57c7041be1e650e52ea9985.html

2.4Myeclipse优化

MyEclipse，新版本的特性能够大大提高开发者的效率。但同时，由于电脑配置的原因，很多开发者在使用MyEclipse的时候，速度都不是很快，需要我们对MyEclipse进行一些必要的优化。

1、老是弹出Quick update error、关闭MyEclipse的Quick Update自动更新功能

这个问题的解决办法是关闭自动更新：

Windows > Preferences > MyEclipseEnterprise Workbench > Community Essentials,然后把选项 ”Search for new features on startup”的前勾去掉即可。

2、关闭updating indexes

Window > Preferences > MyeclipseEnterprise Workbench > Maven4Myeclipse > Maven>

禁用Download repository index updates on startup。

注意：强调一个问题，很多人发现无法找到这个，原因其实是它已经关闭了。

3、关闭MyEclipse的自动validation

validation有很多，包括xml、jsp、jsf、js等等，我们没有必要全部都去自动校验一下，只是需要的时候才会手工校验一下，速度将很快提升好几个档次。

windows > perferences > myeclipse >validation

将Build下全部勾取消，如果你需要验证某个文件的时候，我们可以单独去验证它。方法是：在需要验证的文件上(右键-> MyEclipse -> Run Validation。

4、启动优化，关闭不需要使用的模块

一个系统20%的功能往往能够满足80%的需求，MyEclipse也不例外，我们在大多数时候只需要20%的系统功能，所以可以将一些不使用的模块禁止加载启动。

Window > Preferences > General >Startup andy Shutdown在这里列出的是MyEclipse启动时加载的模块。

我这里只让它加载tomcat5，勾选MyEclipseEASIE Tomcat 5。接下来，关闭工作空间启动刷新：

接下来关闭拼写检查：

只需要取消Enable spell checking：

 

 

 

看到auto activation triggers for Java之后，在里面输入a-z这些字幕吧，然后选择应用，接着去编辑器里查看提示，上面那个选项是延迟多少时间提示，建议不修改。

如图那样选择就完成了，然后我们到myeclipse安装目录>myeclipse.ini打开修改这个文件，建议在做之前备份，不然错了没法启动。

1. -startup  

2. ../Common/plugins/org.eclipse.equinox.launcher_1.0.201.R35x_v20090715.jar 

3. --launcher.library 

4. ../Common/plugins/org.eclipse.equinox.launcher.win32.win32.x86_1.0.200.v20090519 

5. -install  

6. E:/develop/MYEC85/MyEclipse 8.5 M2 

7. -vm  

8. E:/develop/MYEC85/Common/binary/com.sun.java.jdk.win32.x86_1.6.0.013/jre/bin/client/jvm.dll 

9. -vmargs  

10.-Xmx512m  

11.-XX:MaxPermSize=512m 

12.-XX:ReservedCodeCacheSize=256m 

主要是修改： 

1. -Xmx512m  

2. -XX:MaxPermSize=512m 

3. -XX:ReservedCodeCacheSize=256m 

这三个优化方案，最好按照自己的内存来选择，选择合适的话，相信效果会很不错。如果修改后无法使用就能把备份覆盖回来吧。

2.5 tomcat性能优化

http://www.cnblogs.com/ggjucheng/archive/2013/04/16/3024731.html