超大數據量操做 java程序優化[轉載]

 

 

 

 

一個表中有1000萬以上的數據，要對其進行10萬次以上的增刪查改的操做，請問如何優化java程序對數據庫的操做？

經過使用一些輔助性工具來找到程序中的瓶頸，而後就能夠對瓶頸部分的代碼進行優化。通常有兩種方案：即優化代碼或更改設計方法。咱們通常會選擇後者，由於不去調用如下代碼要比調用一些優化的代碼更能提升程序的性能。而一個設計良好的程序可以精簡代碼，從而提升性能。

下面將提供一些在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方法，輸出結果。
     由此能夠看出，這兩行簡單的代碼，就生成了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();
}

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 }
}
}
所以，代碼：
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));
}
}
}

關於線程的操做，要注意以下幾個方面：
(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()命令。