`
jslfl
  • 浏览: 323911 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

java性能优化

JVM 
阅读更多
摘抄自http://www.uml.org.cn


java性能优化-之一
1.对象的生成和大小的调整。
JAVA程序设计中一个普遍的问题就是没有好好的利用JAVA语言本身提供的函数,从而常常会生成大量的对象(或实例)。由于系统不仅要花时间生成对象,以后可能还需花时间对这些对象进行垃圾回收和处理。因此,生成过多的对象将会给程序的性能带来很大的影响。

例1:关于String ,StringBuffer,+和append
JAVA语言提供了对于String类型变量的操作。但如果使用不当,会给程序的性能带来影响。如下面的语句:
String name=new String(“HuangWeiFeng”);
System.out.println(name+”is my name”);
看似已经很精简了,其实并非如此。为了生成二进制的代码,要进行如下的步骤和操作。
(1) 生成新的字符串 new String(STR_1);
(2) 复制该字符串。
(3) 加载字符串常量”HuangWeiFeng”(STR_2);
(4) 调用字符串的构架器(Constructor);
(5) 保存该字符串到数组中(从位置0开始)
(6) 从java.io.PrintStream类中得到静态的out变量
(7) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
(8) 复制该字符串缓冲变量
(9) 调用字符串缓冲的构架器(Constructor);
(10) 保存该字符串缓冲到数组中(从位置1开始)
(11) 以STR_1为参数,调用字符串缓冲(StringBuffer)类中的append方法。
(12) 加载字符串常量”is my name”(STR_3);
(13) 以STR_3为参数,调用字符串缓冲(StringBuffer)类中的append方法。
(14) 对于STR_BUF_1执行toString命令。
(15) 调用out变量中的println方法,输出结果。

由此可以看出,这两行简单的代码,就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五个对象变量。这些生成的类的实例一般都存放在堆中。堆要对所有类的超类,类的实例进行初始化,同时还要调用类极其每个超类的构架器。而这些操作都是非常消耗系统资源的。因此,对对象的生成进行限制,是完全有必要的。
经修改,上面的代码可以用如下的代码来替换。
StringBuffer name=new StringBuffer(“HuangWeiFeng”);
System.out.println(name.append(“is my name.”).toString());


系统将进行如下的操作。
(1) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
(2) 复制该字符串缓冲变量
(3) 加载字符串常量”HuangWeiFeng”(STR_1);
(4) 调用字符串缓冲的构架器(Constructor);
(5) 保存该字符串缓冲到数组中(从位置1开始)
(6) 从java.io.PrintStream类中得到静态的out变量
(7) 加载STR_BUF_1;
(8) 加载字符串常量”is my name”(STR_2);
(9) 以STR_2为参数,调用字符串缓冲(StringBuffer)实例中的append方法。
(10) 对于STR_BUF_1执行toString命令。(STR_3)
(11)调用out变量中的println方法,输出结果。
由此可以看出,经过改进后的代码只生成了四个对象变量:STR_1,STR_2,STR_3和STR_BUF_1.你可能觉得少生成一个对象不会对程序的性能有很大的提高。但下面的代码段2的执行速度将是代码段1的2倍。因为代码段1生成了八个对象,而代码段2只生成了四个对象。
代码段1:
String name= new StringBuffer(“HuangWeiFeng”);
name+=”is my”;
name+=”name”;


代码段2:
StringBuffer name=new StringBuffer(“HuangWeiFeng”);
name.append(“is my”);
name.append(“name.”).toString();


因此,充分的利用JAVA提供的库函数来优化程序,对提高JAVA程序的性能时非常重要的.其注意点主要有如下几方面;
(1) 尽可能的使用静态变量(Static Class Variables)
如果类中的变量不会随他的实例而变化,就可以定义为静态变量,从而使他所有的实例都共享这个变量。
例:
public class foo
{
SomeObject so=new SomeObject();
}


就可以定义为:
public class foo
{
static SomeObject so=new SomeObject();



(2) 不要对已生成的对象作过多的改变。
对于一些类(如:String类)来讲,宁愿在重新生成一个新的对象实例,而不应该修改已经生成的对象实例。
例:
String name=”Huang”;
name=”Wei”;
name=”Feng”;
上述代码生成了三个String类型的对象实例。而前两个马上就需要系统进行垃圾回收处理。如果要对字符串进行连接的操作,性能将得更差。因为系统将不得为此生成更多得临时变量。如上例1所示。 
(3) 生成对象时,要分配给它合理的空间和大小
JAVA中的很多类都有它的默认的空间分配大小。对于StringBuffer类来讲,默认的分配空间大小是16个字符。如果在程序中使用StringBuffer的空间大小不是16个字符,那么就必须进行正确的初始化。
(4) 避免生成不太使用或生命周期短的对象或变量。
对于这种情况,因该定义一个对象缓冲池。以为管理一个对象缓冲池的开销要比频繁的生成和回收对象的开销小的多。
(5) 只在对象作用范围内进行初始化。
JAVA允许在代码的任何地方定义和初始化对象。这样,就可以只在对象作用的范围内进行初始化。从而节约系统的开销。
例:
SomeObject so=new SomeObject();
If(x==1) then
{
Foo=so.getXX();
}
可以修改为:
if(x==1) then
{
SomeObject so=new SomeObject();
Foo=so.getXX();
}

from-: http://www.computerworld.com.cn/

java性能优化-之二
2.异常(Exceptions)
JAVA语言中提供了try/catch来发方便用户捕捉异常,进行异常的处理。但是如果使用不当,也会给JAVA程序的性能带来影响。因此,要注意以下两点。
(1) 避免对应用程序的逻辑使用try/catch
如果可以用if,while等逻辑语句来处理,那么就尽可能的不用try/catch语句
(2) 重用异常
在必须要进行异常的处理时,要尽可能的重用已经存在的异常对象。以为在异常的处理中,生成一个异常对象要消耗掉大部分的时间。
3. 线程(Threading)
一个高性能的应用程序中一般都会用到线程。因为线程能充分利用系统的资源。在其他线程因为等待硬盘或网络读写而 时,程序能继续处理和运行。但是对线程运用不当,也会影响程序的性能。
例2:正确使用Vector类
Vector主要用来保存各种类型的对象(包括相同类型和不同类型的对象)。但是在一些情况下使用会给程序带来性能上的影响。这主要是由Vector类的两个特点所决定的。第一,Vector提供了线程的安全保护功能。即使Vector类中的许多方法同步。但是如果你已经确认你的应用程序是单线程,这些方法的同步就完全不必要了。第二,在Vector查找存储的各种对象时,常常要花很多的时间进行类型的匹配。而当这些对象都是同一类型时,这些匹配就完全不必要了。因此,有必要设计一个单线程的,保存特定类型对象的类或集合来替代Vector类.用来替换的程序如下(StringVector.java):

public class StringVector 
{
private String[] data;
private int count;
public StringVector() { this(10); // default size is 10 }
public StringVector(int initialSize) 
{
data = new String[initialSize];
}
public void add(String str) 
{
// ignore null strings
if(str == null) { return; }
ensureCapacity(count + 1);
data[count++] = str;
}

private void ensureCapacity(int minCapacity) 
{
int oldCapacity = data.length;
if (minCapacity > oldCapacity) 
{
String oldData[] = data;
int newCapacity = oldCapacity * 2;
data = new String[newCapacity];
System.arraycopy(oldData, 0, data, 0, count);
}
}
public void remove(String str) 
{
if(str == null) { return // ignore null str }
for(int i = 0; i < count; i++) 

// check for a match
if(data[i].equals(str)) 
{
System.arraycopy(data,i+1,data,i,count-1); // copy data 
// allow previously valid array element be gc'd
data[--count] = null;
return;
}
}
}
public final String getStringAt(int index) {
if(index < 0) { return null; } 
else if(index > count)

return null; // index is > # strings
}
else { return data[index]; // index is good }
}
/* * * * * * * * * * * * * * * *StringVector.java * * * * * * * * * * * * * * * * */
因此,代码:
Vector Strings=new Vector();
Strings.add(“One”);
Strings.add(“Two”);
String Second=(String)Strings.elementAt(1);
可以用如下的代码替换:
StringVector Strings=new StringVector();
Strings.add(“One”);
Strings.add(“Two”);
String Second=Strings.getStringAt(1); 
这样就可以通过优化线程来提高JAVA程序的性能。用于测试的程序如下(TestCollection.java): 
import java.util.Vector;
public class TestCollection 
{
public static void main(String args []) 
{
TestCollection collect = new TestCollection();
if(args.length == 0) 
{
System.out.println(
"Usage: java TestCollection [ vector | stringvector ]");
System.exit(1);
}
if(args[0].equals("vector")) 
{
Vector store = new Vector();
long start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++) 

store.addElement("string");
}
long finish = System.currentTimeMillis();
System.out.println((finish-start));
start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++) 
{
String result = (String)store.elementAt(i);
}
finish = System.currentTimeMillis();
System.out.println((finish-start));
}
else if(args[0].equals("stringvector")) 
{
StringVector store = new StringVector();
long start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++) { store.add("string"); }
long finish = System.currentTimeMillis();
System.out.println((finish-start));
start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++) {
String result = store.getStringAt(i);
}
finish = System.currentTimeMillis();
System.out.println((finish-start));
}
}
}
/* * * * * * * * * * * * * * * *TestCollection.java * * * * * * * * * * * * * * * * */
测试的结果如下(假设标准的时间为1,越小性能越好):


关于线程的操作,要注意如下几个方面。 
(1) 防止过多的同步
如上所示,不必要的同步常常会造成程序性能的下降。因此,如果程序是单线程,则一定不要使用同步。
(2) 同步方法而不要同步整个代码段
   对某个方法或函数进行同步比对整个代码段进行同步的性能要好。
(3) 对每个对象使用多”锁”的机制来增大并发。
一般每个对象都只有一个”锁”,这就表明如果两个线程执行一个对象的两个不同的同步方法时,会发生”死锁”。即使这两个方法并不共享任何资源。为了避免这个问题,可以对一个对象实行”多锁”的机制。如下所示:
class foo
{
private static int var1;
private static Object lock1=new Object();
private static int var2;
private static Object lock2=new Object();
public static void increment1()
{
synchronized(lock1)
{
var1++;
}
}
public static void increment2()
{
synchronized(lock2)
{
var2++;
}
}
}
4.输入和输出(I/O)
输入和输出包括很多方面,但涉及最多的是对硬盘,网络或数据库的读写操作。对于读写操作,又分为有缓存和没有缓存的;对于数据库的操作,又可以有多种类型的JDBC驱动器可以选择。但无论怎样,都会给程序的性能带来影响。因此,需要注意如下几点:
(1) 使用输入输出缓冲
   尽可能的多使用缓存。但如果要经常对缓存进行刷新(flush),则建议不要使用缓存。
(2) 输出流(Output Stream)和Unicode字符串 
   当时用Output Stream和Unicode字符串时,Write类的开销比较大。因为它要实现Unicode到字节(byte)的转换.因此,如果可能的话,在使用Write类之前就实现转换或用OutputStream类代替Writer类来使用。
(3) 当需序列化时使用transient
   当序列化一个类或对象时,对于那些原子类型(atomic)或可以重建的原素要表识为transient类型。这样就不用每一次都进行序列化。如果这些序列化的对象要在网络上传输,这一小小的改变对性能会有很大的提高。  
(4) 使用高速缓存(Cache)
   对于那些经常要使用而又不大变化的对象或数据,可以把它存储在高速缓存中。这样就可以提高访问的速度。这一点对于从数据库中返回的结果集尤其重要。
(5) 使用速度快的JDBC驱动器(Driver)
   JAVA对访问数据库提供了四种方法。这其中有两种是JDBC驱动器。一种是用JAVA外包的本地驱动器;另一种是完全的JAVA驱动器。具体要使用哪一种得根据JAVA布署的环境和应用程序本身来定。
5.一些其他的经验和技巧
(1) 使用局部变量
(2) 避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量。
(3) 避免在循环中生成同一个变量或调用同一个函数(参数变量也一样)
(4) 尽可能的使用static,final,private等关键字
(5) 当复制大量数据时,使用System.arraycopy()命令。
from-: http://www.computerworld.com.cn/

java性能优化-之三
Java使得复杂应用的开发变得相对简单。毫无疑问,它的这种易用性对Java的大范围流行功不可没。然而,这种易用性实际上是一把双刃剑。一个设计良好的Java程序,性能表现往往不如一个同样设计良好的C++程序。在Java程序中,性能问题的大部分原因并不在于Java语言,而是在于程序本身。养成好的代码编写习惯非常重要,比如正确地、巧妙地运用java.lang.String类和java.util.Vector类,它能够显著地提高程序的性能。下面我们就来具体地分析一下这方面的问题。

在java中,使用最频繁、同时也是滥用最多的一个类或许就是java.lang.String,它也是导致代码性能低下最主要的原因之一。请考虑下面这个例子:


String s1 = "Testing String";
String s2 = "Concatenation Performance";
String s3 = s1 + " " + s2;




几乎所有的Java程序员都知道上面的代码效率不高。那么,我们应该怎么办呢?也许可以试试下面这种代码:


StringBuffer s = new StringBuffer();
s.append("Testing String");
s.append(" ");
s.append("Concatenation Performance");
String s3 = s.toString();



这些代码会比第一个代码片段效率更高吗?答案是否定的。这里的代码实际上正是编译器编译第一个代码片段之后的结果。既然与使用多个独立的String对象相比,StringBuffer并没有使代码有任何效率上的提高,那为什么有那么多的Java书籍批评第一种方法、推荐使用第二种方法?

第二个代码片段用到了StringBuffer类(编译器在第一个片段中也将使用StringBuffer类),我们来分析一下StringBuffer类的默认构造函数,下面是它的代码:



public StringBuffer() { this(16); }


默认构造函数预设了16个字符的缓存容量。现在我们再来看看StringBuffer类的append()方法:


public synchronized StringBuffer append(String str) {
if (str == null) {
    str = String.valueOf(str);
  }
int len = str.length();
int newcount = count + len;
if (newcount > value.length) expandCapacity(newcount);
str.getChars(0, len, value, count);
count = newcount; return this;
}



append()方法首先计算字符串追加完成后的总长度,如果这个总长度大于StringBuffer的存储能力,append()方法调用私有的expandCapacity()方法。expandCapacity()方法在每次被调用时使StringBuffer存储能力加倍,并把现有的字符数组内容复制到新的存储空间。

在第二个代码片段中(以及在第一个代码片段的编译结果中),由于字符串追加操作的最后结果是“Testing String Concatenation Performance”,它有40个字符,StringBuffer的存储能力必须扩展两次,从而导致了两次代价昂贵的复制操作。因此,我们至少有一点可以做得比编译器更好,这就是分配一个初始存储容量大于或者等于40个字符的StringBuffer,如下所示:


StringBuffer s = new StringBuffer(45);
s.append("Testing String");
s.append(" ");
s.append("Concatenation Performance");
String s3 = s.toString();



再考虑下面这个例子:
String s = "";
int sum = 0;
for(int I=1; I<10; I++) {
  sum += I;
  s = s + "+" +I
}
s = s + "=" + sum;


分析一下为何前面的代码比下面的代码效率低:


StringBuffer sb = new StringBuffer();
int sum = 0;
for(int I=1;
I<10; I++){
  sum + = I;
  sb.append(I).append("+");
}
String s = sb.append("=").append(sum).toString();



原因就在于每个s = s + "+" + I操作都要创建并拆除一个StringBuffer对象以及一个String对象。这完全是一种浪费,而在第二个例子中我们避免了这种情况。

我们再来看看另外一个常用的Java类——java.util.Vector。简单地说,一个Vector就是一个java.lang.Object实例的数组。Vector与数组相似,它的元素可以通过整数形式的索引访问。但是,Vector类型的对象在创建之后,对象的大小能够根据元素的增加或者删除而扩展、缩小。请考虑下面这个向Vector加入元素的例子:


Object obj = new Object();
Vector v = new Vector(100000);
for(int I=0;
I<100000; I++) { v.add(0,obj); }



除非有绝对充足的理由要求每次都把新元素插入到Vector的前面,否则上面的代码对性能不利。在默认构造函数中,Vector的初始存储能力是10个元素,如果新元素加入时存储能力不足,则以后存储能力每次加倍。Vector类就象StringBuffer类一样,每次扩展存储能力时,所有现有的元素都要复制到新的存储空间之中。下面的代码片段要比前面的例子快几个数量级:


Object obj = new Object();
Vector v = new Vector(100000);
for(int I=0; I<100000; I++) { v.add(obj); }



同样的规则也适用于Vector类的remove()方法。由于Vector中各个元素之间不能含有“空隙”,删除除最后一个元素之外的任意其他元素都导致被删除元素之后的元素向前移动。也就是说,从Vector删除最后一个元素要比删除第一个元素“开销”低好几倍。

假设要从前面的Vector删除所有元素,我们可以使用这种代码:



for(int I=0; I<100000; I++){ v.remove(0); }


但是,与下面的代码相比,前面的代码要慢几个数量级:



for(int I=0; I<100000; I++){ v.remove(v.size()-1); }


从Vector类型的对象v删除所有元素的最好方法是:



v.removeAllElements();


假设Vector类型的对象v包含字符串“Hello”。考虑下面的代码,它要从这个Vector中删除“Hello”字符串:



String s = "Hello"; int i = v.indexOf(s); if(I != -1) v.remove(s);


这些代码看起来没什么错误,但它同样对性能不利。在这段代码中,indexOf()方法对v进行顺序搜索寻找字符串“Hello”,remove(s)方法也要进行同样的顺序搜索。改进之后的版本是:



String s = "Hello"; int i = v.indexOf(s); if(I != -1) v.remove(i);


这个版本中我们直接在remove()方法中给出待删除元素的精确索引位置,从而避免了第二次搜索。一个更好的版本是:



String s = "Hello"; v.remove(s);


最后,我们再来看一个有关Vector类的代码片段:



for(int I=0; I<v.size(); I++) { System.out.println( v.get(I).getClass().toString()); }


如果v包含100,000个元素,这个代码片段将调用v.size()方法100,000次。虽然size方法是一个简单的方法,但它仍旧需要一次方法调用的开销,至少JVM需要为它配置以及清除堆栈环境。在这里,for循环内部的代码不会以任何方式修改Vector类型对象v的大小,因此上面的代码最好改写成下面这种形式:



int size = v.size(); for(int I=0; I<size; I++) { System.out.println( v.get(I).getClass().toString()); }


虽然这是一个简单的改动,但它仍旧赢得了性能。毕竟,每一个CPU周期都是宝贵的。

拙劣的代码编写方式导致代码性能下降。但是,正如本文例子所显示的,我们只要采取一些简单的措施就能够显著地改善代码性能。
分享到:
评论

相关推荐

    4本高清中文版Java性能优化经典书籍

    Java性能优化是IT行业中至关重要的一个领域,尤其是在大型企业级应用和互联网服务中,高效的Java代码能够显著提升系统运行效率,降低服务器资源消耗。以下是对这四本经典书籍中的核心知识点的详细介绍: 1. **...

    java性能优化教程

    Java性能优化是提升软件效率和用户体验的关键环节,尤其是在大规模应用和高并发场景中。本教程将深入探讨如何通过各种技术和策略来优化Java程序,确保其高效运行。 首先,理解Java性能的基础是JVM(Java虚拟机)。...

    大话JAVA性能优化

    《大话JAVA性能优化》这份文档深入探讨了Java程序在多个层面的性能调优策略,旨在帮助开发者提高程序运行效率,降低资源消耗,提升用户体验。以下是对这些知识点的详细阐述: 1. **代码层次优化**:在代码编写阶段...

    Java性能优化实战视频全集

    ### Java性能优化实战知识点概述 #### 一、理论分析篇 **1.1 性能优化的衡量指标及注意事项** - **衡量指标**: 包括响应时间、吞吐量、资源利用率等。 - **注意事项**: 在进行性能优化时,需确保优化方案不会引入...

    Java 性能优化实战 21 讲2021年

    │ 开篇词 Java 性能优化,是进阶高级架构师的炼金石.mp4 │ 02 理论分析:性能优化有章可循,谈谈常用的切入点.mp4 │ 03 深入剖析:哪些资源,容易成为瓶颈?.mp4 │ 04 工具实践:如何获取代码性能数据?....

    大话java性能优化 周明耀 完整版

    《大话java性能优化》是周明耀先生的一本深入探讨Java性能调优的专业书籍,其主要内容涵盖了Java程序设计中的各种性能优化策略和技术。这本书旨在帮助开发者理解和掌握如何提升Java应用的运行效率,减少资源消耗,...

    Java 性能优化 一书源码

    Java性能优化是软件开发中的一个关键领域,尤其是在大型企业级应用和高并发系统中。《Java性能优化》一书深入探讨了如何通过各种技术提升Java应用程序的效率和响应速度。以下是一些基于书籍源码和相关文件名的关键...

    java性能优化java性能优化

    Java性能优化是提升Java应用程序效率的关键技术,涵盖了内存管理、代码优化、I/O处理等多个方面。以下是一些关键的性能优化策略: 1. **对象创建与克隆**:使用`new`关键字创建对象时,会调用构造函数链,这可能...

    Java 性能优化实战 21 讲

    在Java性能优化实战的21讲中,涵盖了Java开发中至关重要的性能调优技术,旨在提升应用程序的效率、稳定性和可扩展性。以下是对这些关键知识点的详细解析: 1. **JVM内存模型**:理解Java虚拟机(JVM)的内存结构是...

    大话Java性能优化.epub

    大话java性能优化,pdf版!

    Java性能优化的45个细节.pdf

    根据提供的文件信息,以下是关于Java性能优化的详细知识点,内容包括单例模式的合理应用、静态变量的使用考量、对象创建与垃圾回收策略、final修饰符与内联优化、局部变量与实例变量的性能差异、包装类型与基本类型...

    10种java性能优化方案.docx

    ### Java性能优化方案详解 #### 一、理解性能优化的重要性 在现代软件开发中,特别是在Java领域,性能优化是一项至关重要的任务。随着系统的复杂性和规模不断增长,优化不仅仅是提高用户体验那么简单,更是确保...

    大话JAVA性能优化.pdf

    大话Java性能优化》主要提供Java性能调优方面的参考建议及经验交流。作者力求做到知识的综合传播,而不是仅仅只针对Java虚拟机调优进行讲解,另外力求每一章节都有实际的案例支撑。具体包括:性能优化策略、程序编写...

    Java性能优化技巧集锦

    Java性能优化是提升软件效率和用户体验的关键步骤,涵盖了多种技术和策略。本文将深入探讨Java通用篇、J2EE篇、GUI篇、EJB篇以及缓存优化等方面的知识点,旨在帮助开发者实现更高效的代码。 一、Java通用篇 在Java...

Global site tag (gtag.js) - Google Analytics