如何优化JAVA措施设计和编码，提高JAVA机能

副标题#e#

通过利用一些帮助性东西来找到措施中的瓶颈，然后就可以对瓶颈部门的代码举办优化。一般有两种方案：即优化代码或变动设计要领。我们一般会选择后者，因为不去挪用以下代码要比挪用一些优化的代码更能提高措施的机能。而一个设计精采的措施可以或许精简代码，从而提高机能。

下面将提供一些在JAVA措施的设计和编码中，为了可以或许提高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要领，输出功效。

#p#副标题#e#

由此可以看出，这两行简朴的代码，就生成了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();

#p#副标题#e#

因此，充实的操作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";

#p#分页标题#e#

上述代码生成了三个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();
}

#p#副标题#e#

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 }
}
}

#p#副标题#e#

因此，代码：

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）:

#p#分页标题#e#

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));
}
}
}

#p#副标题#e#

关于线程的操纵，要留意如下几个方面：

(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()呼吁。