IT神童

讓Java代碼跑得更快

本文簡單介紹一下在寫代碼過程中用到的一些讓JAVA代碼更高效的技巧。

1,將一些系統資源放在池中,如數據庫連接,線程等.在standalone的應用中,數據庫連接池可以使用一些開源的連接池實現,如C3P0,proxool和DBCP等,在運行在容器中的應用這可以使用服務器提供的DataSource.線程池可以使用JDK本身就提供的java.util.concurrent.ExecutorService.

import java.util.concurrent.Executors;  
import java.util.concurrent.ExecutorService;  
public class JavaThreadPool {  
    public static void main(String[] args) {  
    ExecutorService pool = Executors.newFixedThreadPool(2);  
      
    Thread t1 = new MyThread();  
    Thread t2 = new MyThread();  
    Thread t3 = new MyThread();  
    Thread t4 = new MyThread();  
    Thread t5 = new MyThread();  
 
    pool.execute(t1);  
    pool.execute(t2);  
    pool.execute(t3);  
    pool.execute(t4);  
 
    pool.shutdown();  
    }  
}  
 
class MyThread extends Thread {  
    public void run() {  
    System.out.println(Thread.currentThread().getName() + "running....");  
    }  
}  

2,減少網絡開銷,在和數據庫或者遠程服務交互的時候,盡量將多次調用合并到一次調用中。

3,將經常訪問的外部資源cache到內存中,簡單的可以使用static的hashmap在應用啟動的時候加載,也可以使用一些開源的cache框架,如OSCache和Ehcache等.和資源的同步可以考慮定期輪詢和外部資源更新時候主動通知.或者在自己寫的代碼中留出接口(命令方式或者界面方式)共手動同步。

4,優化IO操作,JAVA操作文件的時候分InputStream and OutputStream,Reader and Writer兩類,stream的方式要快,后者主要是為了操作字符而用的,在字符僅僅是ASCII的時候可以用stream的方式提高效率.JDK1.4之后的nio比io的效率更好。java教程下載

OutputStream out = new BufferedOutputStream(new FileOutputStream(new File("d:/temp/test.txt")));              
out.write("abcde".getBytes());        
out.flush();  
out.close(); 

利用BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter減少對磁盤的直接訪問次數。

FileReader fr = new FileReader(f);  
BufferedReader br = new BufferedReader(fr);  
while (br.readLine() != null) count++; 

5不要頻繁的new對象,對于在整個應用中只需要存在一個實例的類使用單例模式.對于String的連接操作,使用StringBuffer或者StringBuilder.對于utility類型的類通過靜態方法來訪問。

6,避免使用錯誤的方式,如Exception可以控制方法推出,但是Exception要保留stacktrace消耗性能,除非必要不要使用instanceof做條件判斷,盡量使用比的條件判斷方式.使用JAVA中效率高的類,比如ArrayList比Vector性能好。

7,對性能的考慮要在系統分析和設計之初就要考慮。

總之,一個系統運行時的性能,無非是從CPU,Memory和IO這三個主要方面來考慮優化.減少不必要的CPU消耗,減少不必要的IO操作,增加Memory利用效率。

posted @ 2012-08-23 14:42 IT神童 閱讀(549) | 評論 (0) | 編輯 收藏

Java高并發：靜態頁面生成方案

提升網站性能的方式有很多，例如有效的使用緩存，生成靜態頁面等等。今天要說的就是生成靜態頁面的方式。這個也是我近期一直在搞的一個問題，近期在做使用html + servlet做個人網站，為什么是這2個東西呢？

1、直接用servlet是為了保證網站能以最快的速度執行命令個人總感覺像Struts hibernate spring之類的雖然方便但是效能帶來的損耗不太能接收

2、使用html同樣是為了保證最快的反應速度，畢竟html 比jsp少了一層服務器執行。速度上要快的多

一、在這里要先說一下什么是頁面靜態化：

簡單的說，我們如果訪問一個鏈接 ,服務器對應的模塊會處理這個請求，轉到對應的jsp界面，最后生成我們想要看到的數據。這其中的缺點是顯而易見的：因為每次請求服務器都會進行處理，如果有太多的高并發請求，那么就會加重應用服務器的壓力，弄不好就把服務器 搞down 掉了。那么如何去避免呢？如果我們把對 test.do 請求后的結果保存成一個 html 文件，然后每次用戶都去訪問 ,這樣應用服務器的壓力不就減少了？

那么靜態頁面從哪里來呢？總不能讓我們每個頁面都手動處理吧？這里就牽涉到我們要講解的內容了，靜態頁面生成方案… 我們需要的是自動的生成靜態頁面，當用戶訪問 ,會自動生成 test.html ,然后顯示給用戶。

二、下面我們在簡單介紹一下要想掌握頁面靜態化方案應該掌握的知識點

1、 基礎- URL Rewrite

什么是 URL Rewrite 呢 ? URL 重寫。用一個簡單的例子來說明問題：輸入網址 ,但是實際上訪問的卻是 abc.com/test.action,那我們就可以說 URL 被重寫了。這項技術應用廣泛，有許多開源的工具可以實現這個功能。java電子書免費下載2、 基礎- Servlet web.xml

如果你還不知道 web.xml 中一個請求和一個 servlet 是如何匹配到一起的，那么請搜索一下 servlet 的文檔。這可不是亂說呀，有很多人就認為 /xyz/*.do 這樣的匹配方式能有效。

如果你還不知道怎么編寫一個 servlet ,那么請搜索一下如何編寫 servlet.這可不是說笑呀，在各種集成工具漫天飛舞的今天，很多人都不會去從零編寫一個 servlet了。

三、基本的方案介紹

其中，對于 URL Rewriter的部分，可以使用收費或者開源的工具來實現，如果 url不是特別的復雜，可以考慮在 servlet 中實現，那么就是下面這個樣子：
 

posted @ 2012-08-23 14:41 IT神童 閱讀(153) | 評論 (0) | 編輯 收藏

公司的Java框架應具備的通用功能

以前在學校的時候自己以為是不是每個做JAVA開發的公司每次做項目的時候都要搭建一個SSH框架呢，工作之后才發現每個公司都有自己的一套框架，要不是在SSH基礎上，要不是在SSI基礎上進行了符合自己公司需求的封裝，并且隨著自己公司的框架被應用到各個實際系統的過程中，這個框架會越來越成熟，會使該公司的開發效率越來越高。

根據筆者接觸過的幾個公司的框架，筆者發現要想實現高效的開發，每個公司的框架應該具備如下的特點：

1.具有靈活的分頁功能。

分頁功能是每個項目中必須要實現的功能，而恰恰這個功能是比較費時費力的，如果在框架中實現這一功能，將在每個項目中大大減少分頁的重復性工作。

2.可以方便的實現文件的上傳與下載、數據的導入和導出的功能。

文件的上傳于下載、數據的導入和導出在大部門項目中也會遇到，但是這兩個功能可能會因為項目的不同導致實現上有一點區別，我們框架中要做的就是應該抽出其中共有的東西，定義為抽象的東西，以便不同的項目、不同的需求都能很容易的實現該功能。成都java培訓機構
3.方便的事務管理功能。

事務管理一般來說都定義在業務邏輯層。我們框架中應該實現對業務邏輯對象事務的簡單配置甚至是零配置。筆者接觸過的兩個框架中，一個需要在配置完一個業務邏輯對象時，在事務管理的配置文件中加上一句簡單的配置即可，另一個是框架中實現了幾個基本的業務邏輯對象，并對這幾個對象實現了事務管理的配置，開發的時候定義的業務邏輯對象都是繼承自這幾個基本對象，也就省去了事務管理的配置。

4.具有異常處理框架。

基本上每個項目的異常處理都應該可以使用公司的框架定義的異常處理框架，并不會因為項目的不同而要求的異常處理也不一樣。

5.具有自己的一套頁面組件。

項目開發都是團隊的開發，要想保證每個開發人員的界面風格統一，最好的辦法就是定義一套公司自己的頁面組建。這樣既能保證開發效率，也能做到界面的統一。freemark就是不錯的選擇，其支持自定義宏，公司框架中可以定義一套自己的頁面組建宏，供開發人員調用即可。

6.具有數據校驗框架。

每個項目在數據校驗時都可能會用到大量的正則表達式，那么在公司的框架中將這些正則表達式封裝起來，提供統一的調用接口將是不錯的選擇。

7.簡單的實現菜單的配置。

一個好的框架應該提供對菜單、二級菜單等的簡單配置、管理。還是上文提到的兩個框架，一個是通過XML配置文件實現了對系統中一級菜單、二級菜單、三級菜單的管理，而另個框架要實現相同的需求卻要在數據庫中進行繁瑣的配置，顯然第一個框架的實現方案更可取、更高效。

posted @ 2012-08-23 14:40 IT神童 閱讀(278) | 評論 (1) | 編輯 收藏

Java中用內存映射處理大文件

在處理大文件時，如果利用普通的FileInputStream 或者FileOutputStream 抑或RandomAccessFile 來進行頻繁的讀寫操作，都將導致進程因頻繁讀寫外存而降低速度.如下為一個對比實驗。

1. package test;  
2.  
3. import java.io.BufferedInputStream;  
4. import java.io.FileInputStream;  
5. import java.io.FileNotFoundException;  
6. import java.io.IOException;  
7. import java.io.RandomAccessFile;  
8. import java.nio.MappedByteBuffer;  
9. import java.nio.channels.FileChannel;  
10.  
11. public class Test {  
12.  
13.       
14.     public static void main(String[] args) {  
15.         try {  
16.             FileInputStream fis=new FileInputStream("/home/tobacco/test/res.txt");  
17.             int sum=0;  
18.             int n;  
19.             long t1=System.currentTimeMillis();  
20.             try {  
21.                 while((n=fis.read())>=0){  
22.                     sum+=n;  
23.                 }  
24.             } catch (IOException e) {  
25.                 // TODO Auto-generated catch block  
26.                 e.printStackTrace();  
27.             }  
28.             long t=System.currentTimeMillis()-t1;  
29.             System.out.println("sum:"+sum+"  time:"+t);  
30.         } catch (FileNotFoundException e) {  
31.             // TODO Auto-generated catch block  
32.             e.printStackTrace();  
33.         }  
34.           
35.         try {  
36.             FileInputStream fis=new FileInputStream("/home/tobacco/test/res.txt");  
37.             BufferedInputStream bis=new BufferedInputStream(fis);  
38.             int sum=0;  
39.             int n;  
40.             long t1=System.currentTimeMillis();  
41.             try {  
42.                 while((n=bis.read())>=0){  
43.                     sum+=n;  
44.                 }  
45.             } catch (IOException e) {  
46.                 // TODO Auto-generated catch block  
47.                 e.printStackTrace();  
48.             }  
49.             long t=System.currentTimeMillis()-t1;  
50.             System.out.println("sum:"+sum+"  time:"+t);  
51.         } catch (FileNotFoundException e) {  
52.             // TODO Auto-generated catch block  
53.             e.printStackTrace();  
54.         }  
55.           
56.         MappedByteBuffer buffer=null;  
57.         try {  
58.             buffer=new RandomAccessFile("/home/tobacco/test/res.txt","rw").getChannel().map(FileChannel.MapMode.READ_WRITE, 0, 1253244);  
59.             int sum=0;  
60.             int n;  
61.             long t1=System.currentTimeMillis();  
62.             for(int i=0;i<1253244;i++){  
63.                 n=0x000000ff&buffer.get(i);  
64.                 sum+=n;  
65.             }  
66.             long t=System.currentTimeMillis()-t1;  
67.             System.out.println("sum:"+sum+"  time:"+t);  
68.         } catch (FileNotFoundException e) {  
69.             // TODO Auto-generated catch block  
70.             e.printStackTrace();  
71.         } catch (IOException e) {  
72.             // TODO Auto-generated catch block  
73.             e.printStackTrace();  
74.         }  
75.  
76.     }  
77.  
78. }  

java基礎教程測試文件為一個大小為1253244字節的文件。測試結果：

sum:220152087 time:1464  
sum:220152087 time:72  
sum:220152087 time:25 

說明讀數據無誤。刪去其中的數據處理部分。

package test;  
 
import java.io.BufferedInputStream;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.IOException;  
import java.io.RandomAccessFile;  
import java.nio.MappedByteBuffer;  
import java.nio.channels.FileChannel;  
 
public class Test {  
 
      
    public static void main(String[] args) {  
        try {  
            FileInputStream fis=new FileInputStream("/home/tobacco/test/res.txt");  
            int sum=0;  
            int n;  
            long t1=System.currentTimeMillis();  
            try {  
                while((n=fis.read())>=0){  
                    //sum+=n;  
                }  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
            long t=System.currentTimeMillis()-t1;  
            System.out.println("sum:"+sum+"  time:"+t);  
        } catch (FileNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
          
        try {  
            FileInputStream fis=new FileInputStream("/home/tobacco/test/res.txt");  
            BufferedInputStream bis=new BufferedInputStream(fis);  
            int sum=0;  
            int n;  
            long t1=System.currentTimeMillis();  
            try {  
                while((n=bis.read())>=0){  
                    //sum+=n;  
                }  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
            long t=System.currentTimeMillis()-t1;  
            System.out.println("sum:"+sum+"  time:"+t);  
        } catch (FileNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
          
        MappedByteBuffer buffer=null;  
        try {  
            buffer=new RandomAccessFile("/home/tobacco/test/res.txt","rw").getChannel().map(FileChannel.MapMode.READ_WRITE, 0, 1253244);  
            int sum=0;  
            int n;  
            long t1=System.currentTimeMillis();  
            for(int i=0;i<1253244;i++){  
                //n=0x000000ff&buffer.get(i);  
                //sum+=n;  
            }  
            long t=System.currentTimeMillis()-t1;  
            System.out.println("sum:"+sum+"  time:"+t);  
        } catch (FileNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
 
    }  
 
} 

測試結果：

sum:0 time:1458  
sum:0 time:67  
sum:0 time:8 

由此可見，將文件部分或者全部映射到內存后進行讀寫，速度將提高很多。

這是因為內存映射文件首先將外存上的文件映射到內存中的一塊連續區域，被當成一個字節數組進行處理，讀寫操作直接對內存進行操作，而后再將內存區域重新映射到外存文件，這就節省了中間頻繁的對外存進行讀寫的時間，大大降低了讀寫時間。

posted @ 2012-08-23 14:37 IT神童 閱讀(221) | 評論 (0) | 編輯 收藏