1.表名要以模塊簡稱為前綴, 如：Bse_, Crm_, Sys_, Scm_, OA_, Mrp_, Ftm_等，后面部分與字段名稱都盡量使用有意義的英文單詞，第一個字母要大寫，單詞之間直接連接，不需要連接符號；

2.每個表必須要有主鍵，而且對經常使用的字段建立索引，除了必要的字段，盡可能設置字段允許為空而且不需要缺省值；

3.主鍵規則：對于經常增刪的數據表，主鍵字段建議為varchar(36)，用GUID生成，其它表原則上以性能為參考來建立主鍵，但要考慮可移植性，并發性與易初始化；主鍵本身在業務邏輯上不體現，不具有實際意義；

4.避免使用復合主鍵，只比較一個字段比比較多個字段快很多；

5.除了必要的冗余數據外，盡量避免冗余數據的出現，容易保證數據的一致性；

6.完全符合建立聚集索引要求：“既不能絕大多數都相同，又不能只有極少數相同”的規則；

7.用聚合索引比用不是聚合索引的主鍵速度快；

8.用聚合索引比用一般的主鍵作order by時速度快；

9.使用聚合索引內的字段，搜索時間會按數據占整個數據表的百分比成比例減少；

10.索引有助于提高檢索性能，但過多或不當的索引也會導致系統低效，過多的索引甚至會導致索引碎片；

11.Like條件中，通配符%在字符串的開頭使得索引無法使用；

12.OR條件，會引起全表掃描；

13.不推薦使用以下條件語句：NOT、!=、<>、!<、!>、NOT EXISTS、NOT IN、NOT LIKE；

14.IN 的作用相當與OR；

15.盡量少用NOT；

16.exists 和 in 的執行效率是一樣的；

17.用函數charindex()和前面加通配符%的LIKE執行效率一樣；

18.union在通常情況下比用or的效率要高的多，但如果or兩邊的查詢列是一樣的話，那么用union則反倒和用or的執行速度差很多；

19.字段提取要按照“需多少、提多少”的原則，避免“select *”；

20.count(*)不比count(主鍵)慢，而count(*)卻比其他任何除主鍵以外的字段匯總速度要快，而且字段越長，匯總速度就越慢；

21.order by按聚集索引列排序效率最高；

22.高效的TOP，提高性能；

23.聚集索引有兩個最大的優勢：1、以最快的速度縮小查詢范圍；2、以最快的速度進行字段排序；

24.一定要將聚集索引建立在：1、您最頻繁使用的、用以縮小查詢范圍的字段上；2、您最頻繁使用的、需要排序的字段上；

25. 由于改變一個表的內容，將會引起索引的變化。頻繁的insert,update,delete語句將導致系統花費較大的代價進行索引更新，引起整體性能的下降。一般來講，在對查詢性能的要求高于對數據維護性能要求時，應該盡量使用索引，否則，就要慎重考慮一下付出的代價；

26. 不同類型的索引效能是不一樣的，應盡可能先使用效能高的,比如：數字類型的索引查找效率高于字符串類型，定長字符串char，nchar的索引效率高于變長字符串varchar,nvarchar的索引；

27. 有嵌套查詢時，盡可能在內層過濾掉數據；

28. 多表關聯查詢時，需注意表順序，并盡可能早的過濾掉數據，只將必須的數據帶到后續的操作中去；

29. 任何對列的操作都導致全表掃描，如數據庫函數、計算表達式等，查詢時應盡可能將操作移至等號的某一邊；

30. 存儲過程如果有返回結果集的話, 就不能通過返回一個狀態值來進行邏輯判斷,否則會導致執行兩次存儲過程,影響性能;

31. Where條件中如果存在以下情況,則索引無效,嚴重影響性能: 索引列不要使用函數; 索引列不要使用NOT; 索引列不要用NULL; 不要對索引列進行計算;

1. JSP頁面的編碼標準: UTF-8;

2. 有調用request對象的頁面加上: <%request.setCharacterEncoding("UTF-8");%>;

3. 有調用response對象的頁面加上: <%response.setCharacterEncoding("UTF-8");%>;

4. sendRedirect的調用需對中文等多字節參數進行編碼: URLEncoder.encode(argname,"UTF-8");

5. 不要在頁面中調用以下函數: out.close();

6. 不要在頁面中調用以下函數: response.getOutputStream(),應該使用out對象,或者使用Servlet;

7. 頁面文件轉換為UTF-8文件的方法: 先用記事本打開,另存為UTF-8字符集, 加入編碼UTF-8字符集, 然后再用NB IDE打開即可;

8. 不要調用標記為廢棄的函數;

9. 所有可以點擊查看內容的文字, 使用類: LinkText; 如: <span class="LinkText" ...

10. 取記錄集顯示時,循環中不能再進行數據庫連接操作, 用Left Join或存儲過程替換;

11. 程序文件目錄與文件名稱,命名一定要統一,采用JAVA的命名規則,用英文且大小寫分開,同樣功能的頁面命名保持統一, 以便維護;

1. 每個文件的頭部注釋: 版權說明、版本號、生成日期、作者、內容、功能、與其它文件的關系、修改日志等，頭文件的注釋中還應有函數功能簡要說明;

2. 函數頭部應進行注釋：函數的目的/功能、輸入參數、輸出參數、返回值、調用關系（函數、表）、作者或修改人等;

3. 對變量的定義和分支語句（條件分支、循環語句等）必須編寫注釋;

4. 自己特有的命名風格，要自始至終保持一致，不可來回變化;

5. 類命名標準: 由兩個或以上的相近意義的英文單詞組成,首字母大寫;

6. 一個類里面只能實現一個單據或一個功能的不同操作方面,盡可能減少類之間的耦合性;

7. 一些通用功能,都分類封裝成不同的實用操作類;

8. 對以前的對象或函數重構或重命名時, 必須由修改人搜索以前的所有調用并替換,同時通知其它人以后使用新的調用;

9. 注釋格式 /** * Setting to true will enable the display of debug information. * * @param d A boolean. * @return An Email. * @throws EmailException * @version Version * @author Author * @since 1.0 */

10. 類包規范: path.crm(itm,system,basic,oa,wms,mrp,scm).entity(manager),按模塊分開類,同時實體類與操作類分開,映射文件跟實體類同目錄;path.util下為實用類;Servlet映射為二級目錄,目前為/path/system;

11. 頁面不允許RS對象引用,全部用List或HashMap來實現;

12. 參數傳遞盡可能使用實體類, 沒有實體類的使用HashMap;

13. 方法重載時, 可替換的不能使用重載;

14. 嚴格按照代碼縮進格式進行代碼書寫,包括各種操作與分隔符號兩邊的空格;

15. 模糊搜索關鍵字,可以輸入如"ab,abc"以逗號分隔的多個關鍵字進行搜索;

16. 變量命名規則: 數據類型簡寫+首字母大寫的變量英文名稱, 如果是全局變量加上小寫g, 如: gszLimitString, gnModuleFlag, gnPageSize;

17. 程序中,SQL語句不能包含方括號, SQL語句中的表別名不能加AS,用空格代替;

18. SQL字符串,不能直接拼接字符串變量,用SET方法實現變量賦值,避免非法字符串變量引起安全問題;

19. 必須隨時關閉所用的ResultSet,Statement對象,最好用finally實現,避免錯誤時沒有關閉的問題;

20. 附件管理: 文件大小統一用text.formatFileSize()進行格式化;查看與下載鏈接用SPAN標簽;

21. 其它詳細的請參見公司的“軟件編程規范檢查”；

1. 有"+"操作的字符串, 使用StringBuffer代替String;

2. 生成對象時，分配合理的空間和大小,如StringBuffer,Vector的初始化大小;

3. 優化循環體,避免在循環中生成同一個變量或調用同一個函數（參數變量也一樣）;

4. 盡量在使用時才創建該對象; 應該盡量重復使用一個對象，而不是聲明新的同類對象;

5. 盡量使用局部變量; 盡量使用靜態變量，從而使他所有的實例都共享這個變量;

6. 盡量減少方法的調用, 可事先判斷, 同時用變量替換;

7. 盡量使用Java系統API,如復制大量數據時，使用System.arraycopy();

8. 盡可能使用帶有Buffer的類代替沒有Buffer的類;

9. 不用保存太多的信息在HttpSession中, 同時注意清除Session;

10. 大型數據量處理或批處理數據記錄,盡量使用直接訪問數據庫的方法，用SQL直接存取數據;

11. 在生產環境下,禁止servlet和jsp的自動重載;

12. 插入下述“顯式”計時代碼，對程序進行評測：

long start = System.currentTimeMillis(); // 要計時的運算代碼放在這兒,返回的時間以千分之一秒（1毫秒）為單位 long time = System.currentTimeMillis() - start;

13. 常用運算時間單位: 運算 示例 標準時間本地賦值 i=n; 1.0 實例賦值 this.i=n; 1.2 int增值 i++; 1.5 byte增值 b++; 2.0 short增值 s++; 2.0 float增值 f++; 2.0 double增值 d++; 2.0 空循環 while(true) n++; 2.0 三元表達式 (x<0) ?-x : x 2.2 算術調用 Math.abs(x); 2.5 數組賦值 a[0] = n; 2.7 long增值 l++; 3.5 方法調用 funct(); 5.9 throw或catch異常 try{ throw e; }或catch(e){} 320 同步方法調用 synchMehod(); 570 新建對象 new Object(); 980 新建數組 new int[10]; 3100

時間：2006-08-16 作者：axman 瀏覽次數： 3723 本文關鍵字：Java,?多線程,?線程,?線程對象,?單線程,?go deep into java

文章工具 ?推薦給朋友 ?打印文章

　　在進入java平臺的線程對象之前，基于基礎篇（一）的一些問題，我先插入兩個基本概念。

[線程的并發與并行]

　　在單CPU系統中，系統調度在某一時刻只能讓一個線程運行，雖然這種調試機制有多種形式(大多數是時間片輪巡為主)，但無論如何，要通過不斷切換需要運行的線程讓其運行的方式就叫并發(concurrent)。而在多CPU系統中，可以讓兩個以上的線程同時運行，這種可以同時讓兩個以上線程同時運行的方式叫做并行(parallel)。

　　在上面包括以后的所有論述中，請各位朋友諒解，我無法用最準確的詞語來定義儲如并發和并行這類術語，但我以我的經驗能通俗地告訴大家它是怎么一回事，如果您看到我說的一些"標準"文檔上說的不一樣，只要意思一致，那您就不要挑刺了。

[JAVA線程對象]

　　現在我們來開始考察JAVA中線程對象。

　　在JAVA中，要開始一個線程，有兩種方式。一是直接調用Thread實例的start()方法，二是
將Runable實例傳給一個Thread實例然后調用它的start()方法。

　　在前面已經說過，線程對象和線程是兩個完全不同的概念。這里我們再次深入一下，生成一個線程的實例，并不代表啟動了線程。而啟動線程是說在某個線程對象上啟動了該實例對應的線程，當該線程結束后，并不會就立即消失。

　　對于從很多書籍上可以看到的基礎知識我就不用多說了。既然是基礎知識，我也著重于從普通文檔上讀不到的內容。所以本節我重點要說的是兩種線程對象產生線程方式的區別。

class MyThread extends Thread{
  public int x = 0;
  
  public void run(){
    
    for(int i=0;i<100;i++){
      try{
        Thread.sleep(10);
      }catch(Exception e){}
      System.out.println(x++);
      
    }
  }
}

　　如果我們生成MyThread的一個實例，然后調用它的start()方法，那么就產生了這個實例對應的線程：

public class Test {
  public static void main(String[] args) throws Exception{
    MyThread mt = new MyThread();
    mt.start();
  }
}

　　不用說，最終會打印出0到99，現在我們稍微玩一點花樣：

public class Test {
  public static void main(String[] args) throws Exception{
    MyThread mt = new MyThread();
    mt.start();
    System.out.println(101);
  }
}

　　也不用說，在基礎篇（一）中我們知道由于單CPU的原因，一般會先打印101，然后打印0到99。不過我們可以控制線程讓它按我們的意思來運行：

public class Test {
  public static void main(String[] args) throws Exception{
    MyThread mt = new MyThread();
    mt.start();
    mt.join();
    System.out.println(101);
  }
}

　　好了，我們終于看到，mt實例對應的線程(假如我有時說mt線程請你不要怪我，不過我盡量不這么說)。在運行完成后，主線程才打印101。因為我們讓當前線程(這里是主線程)等待mt線程的運行結束。"在線程對象a上調用join()方法，就是讓當前正在執行的線程等待線程對象a對應的線程運行完成后才繼續運行。"?請大家一定要深刻理解并熟記這句話，而我這里引出這個知識點的目的是為了讓你繼續看下面的例子：

public class Test {
  public static void main(String[] args) throws Exception{
    MyThread mt = new MyThread();
    mt.start();
    mt.join();
    Thread.sleep(3000);
    mt.start();
  }
}

　　當線程對象mt運行完成后，我們讓主線程休息一下，然后我們再次在這個線程對象上啟動線程。結果我們看到：

　　Exception?in?thread?"main"?java.lang.IllegalThreadStateException

　　也就是這種線程對象一時運行一次完成后，它就再也不能運行第二次了。我們可以看一下它有具體實現:

    public synchronized void start() {
        if (started)
            throw new IllegalThreadStateException();
        started = true;
        group.add(this);
        start0();
    }

　　一個Thread的實例一旦調用start()方法，這個實例的started標記就標記為true，事實中不管這個線程后來有沒有執行到底，只要調用了一次start()就再也沒有機會運行了，這意味著：

[通過Thread實例的start()，一個Thread的實例只能產生一個線程]

　　那么如果要在一個實例上產生多個線程(也就是我們常說的線程池)，我們應該如何做呢？這就是Runnable接口給我們帶來的偉大的功能。

class R implements Runnable{
  private int x = 0;
  public void run(){

    for(int i=0;i<100;i++){
      try{
        Thread.sleep(10);
      }catch(Exception e){}
      System.out.println(x++);

    }
  }
}

　　
正如它的名字一樣，Runnable的實例是可運行的，但它自己并不能直接運行，它需要被Thread對象來包裝才行運行：

public class Test {
  public static void main(String[] args) throws Exception{
    new Thread(new R()).start();
  }
}

　　當然這個結果和mt.start()沒有什么區別。但如果我們把一個Runnable實例給Thread對象多次包裝，我們就可以看到它們實際是在同一實例上啟動線程：

public class Test {
  public static void main(String[] args) throws Exception{
    R r = new R();
    for(int i=0;i<10;i++)
      new Thread(r).start();
  }
}

　　x是實例對象，但結果是x被加到了999，說明這10個線程是在同一個r對象上運行的。請大家注意，因為這個例子是在單CPU上運行的，所以沒有對多個線程同時操作共同的對象進行同步。這里是為了說明的方便而簡化了同步，而真正的環境中你無法預知程序會在什么環境下運行，所以一定要考慮同步。

　　到這里我們做一個完整的例子來說明線程產生的方式不同而生成的線程的區別：

package debug;

import java.io.*;
import java.lang.Thread;


class MyThread extends Thread{
  public int x = 0;

  public void run(){
    System.out.println(++x);
  }
}

class R implements Runnable{
  private int x = 0;
  public void run(){
    System.out.println(++x);
  }
}

public class Test {
  public static void main(String[] args) throws Exception{
    
    for(int i=0;i<10;i++){
      Thread t = new MyThread();
      t.start();
    }
    Thread.sleep(10000);//讓上面的線程運行完成
    R r = new R();
    for(int i=0;i<10;i++){
      Thread t = new Thread(r);
      t.start();
    }
  }
}

　　上面10個線程對象產生的10個線程運行時打印了10次1。下面10個線程對象產生的10個線程運行時打印了1到10。我們把下面的10個線程稱為同一實例(Runnable實例)的多個線程。

　　下節我們將研究線程對象方法，還是那句話，一般文檔中可以讀到的內容我不會介紹太多
請大家自己了解。

個人自述

一個男人.
一個寫程序的男人.
一個寫程序并正在從程序中尋找快樂的男人.
一個寫程序并正在從程序中尋找快樂并把快樂傳遞給大家的男人.

一個書生.
一個寂寞的書生.
一個寂寞的梅香竹影下敲聲寫韻的書生.
一個寂寞的梅香竹影下敲聲寫韻晨鐘暮鼓中逸氣揚劍的書生.

那個男人是位書生。沒有人知道他的姓名，居無定所，行無定蹤，亦耕變讀，或漁或樵。
所以有人叫他樵夫(Axman)，有人叫他漁郎(fisher)。

時間：2006-08-08 作者：axman 瀏覽次數： 5279 本文關鍵字：Java,?多線程,?線程,?線程對象,?單線程,?go deep into java

文章工具 ?推薦給朋友 ?打印文章

　　[寫在前面]

　　隨著計算機技術的發展，編程模型也越來越復雜多樣化。但多線程編程模型是目前計算機系統架構的最終模型。隨著CPU主頻的不斷攀升，X86架構的硬件已經成為瓶，在這種架構的CPU主頻最高為4G。事實上目前3.6G主頻的CPU已經接近了頂峰。

　　如果不能從根本上更新當前CPU的架構(在很長一段時間內還不太可能)，那么繼續提高CPU性能的方法就是超線程CPU模式。那么，作業系統、應用程序要發揮CPU的最大性能，就是要改變到以多線程編程模型為主的并行處理系統和并發式應用程序。

　　所以，掌握多線程編程模型，不僅是目前提高應用性能的手段，更是下一代編程模型的核心思想。多線程編程的目的，就是"最大限度地利用CPU資源"，當某一線程的處理不需要占用CPU而只和I/O,OEMBIOS等資源打交道時，讓需要占用CPU資源的其它線程有機會獲得CPU資源。從根本上說，這就是多線程編程的最終目的。

　　[第一需要弄清的問題]

　　如同程序和進程的區別，要掌握多線程編程，第一要弄清的問題是：線程對象和線程的區別。

　　線程對象是可以產生線程的對象。比如在java平臺中Thread對象，Runnable對象。線程，是指正在執行的一個指點令序列。在java平臺上是指從一個線程對象的start()開始，運行run方法體中的那一段相對獨立的過程。

　　鑒于作者的水平，無法用更確切的詞匯來描述它們的定義。但這兩個有本質區別的概念請初學者細細體會，隨著介紹的深入和例程分析的增加，就會慢慢明白它們所代表的真實含義。

　　天下難事必始于易，天下大事必始于細。

　　讓我們先從最簡單的"單線程"來入手：(1)帶引號說明只是相對而言的單線程，(2)基于java。

    class BeginClass{
        public static void main(String[] args){
            for(int i=0;i<100;i++)
                System.out.println("Hello,World!");
        }
    }

　　如果我們成功編譯了該java文件，然后在命令行上敲入：

　　java?BeginClass

　　現在發生了什么呢？每一個java程序員，從他開始學習java的第一分鐘里都會接觸到這個問

　　題，但是，你知道它到底發生發什么？

　　JVM進程被啟動，在同一個JVM進程中，有且只有一個進程，就是它自己。然后在這個JVM環境中，所有程序的運行都是以線程來運行。JVM最先會產生一個主線程，由它來運行指定程序的入口點。在這個程序中，就是主線程從main方法開始運行。當main方法結束后，主線程運行完成。JVM進程也隨之退出。

　　我們看到的是一個主線程在運行main方法，這樣的只有一個線程執行程序邏輯的流程我們稱

　　之為單線程。這是JVM提供給我們的單線程環境，事實上，JVM底層還至少有垃圾回收這樣的后臺線程以及其它非java線程，但這些線程對我們而言不可訪問，我們只認為它是單線程的。

　　主線程是JVM自己啟動的，在這里它不是從線程對象產生的。在這個線程中，它運行了main方法這個指令序列。理解它，但它沒有更多可以研究的內容。

　　[接觸多線程]

    class MyThread extends Thread{
        public void run(){
            System.out.println("Thread say:Hello,World!");
        }
    }

    public class MoreThreads{
        public static void main(String[] args){
            new MyThread();
            new MyThread().start();
            System.out.println("Main say:Hello,World");
        }
    }

　　執行這個程序，main方法第一行產生了一個線程對象，但并沒有線程啟動。

　　main方法第二行產生了一個線程對象，并啟動了一個線程。

　　main方法第三行，產生并啟動一個線程后，主線程自己也繼續執行其它語句。

　　我們先不研究Thread對象的具體內容，稍微來回想一下上面的兩個概念，線程對象和線程。在JAVA中，線程對象是JVM產生的一個普通的Object子類。而線程是CPU分配給這個對象的一個運行過程。我們說的這個線程在干什么，不是說一個線程對象在干什么，而是這個運行過程在干什么。如果一時想不明白，不要急，但你要記得它們不是一回事就行了。

　　累了吧？為不么不繼續了？

　　基于這種風格來介紹多線程，并不是每個人都喜歡和接受的，如果你不喜歡，正好不浪費你的時間了，而如果你接受的話，那就看下一節吧。

　　轉載自dev2dev網友axman的go deep into java專欄。

個人自述

一個男人.
一個寫程序的男人.
一個寫程序并正在從程序中尋找快樂的男人.
一個寫程序并正在從程序中尋找快樂并把快樂傳遞給大家的男人.

一個書生.
一個寂寞的書生.
一個寂寞的梅香竹影下敲聲寫韻的書生.
一個寂寞的梅香竹影下敲聲寫韻晨鐘暮鼓中逸氣揚劍的書生.

那個男人是位書生。沒有人知道他的姓名，居無定所，行無定蹤，亦耕變讀，或漁或樵。
所以有人叫他樵夫(Axman)，有人叫他漁郎(fisher)。

多線程設計要點

板橋里人 http://www.jdon.com 2002/01/10

1 .多線程中有主內存和工作內存之分， 在JVM中，有一個主內存，專門負責所有線程共享數據；而每個線程都有他自己私有的工作內存， 主內存和工作內存分貝在JVM的stack區和heap區。

2. 線程的狀態有'Ready', 'Running', 'Sleeping', 'Blocked', 和 'Waiting'幾個狀態，
'Ready' 表示線程正在等待CPU分配允許運行的時間。

3. 線程運行次序并不是按照我們創建他們時的順序來運行的，CPU處理線程的順序是不確定的，如果需要確定，那么必須手工介入，使用setPriority()方法設置優先級。

4. 我們無從知道一個線程什么時候運行，兩個或多個線程在訪問同一個資源時，需要synchronized

5. 每個線程會注冊自己，實際某處存在著對它的引用，因此，垃圾回收機制對它就“束手無策”了。

6. Daemon線程區別一般線程之處是：主程序一旦結束，Daemon線程就會結束。

7. 一個對象中的所有synchronized方法都共享一把鎖，這把鎖能夠防止多個方法對通用內存同時進行的寫操作。synchronized static方法可在一個類范圍內被相互間鎖定起來。

8. 對于訪問某個關鍵共享資源的所有方法，都必須把它們設為synchronized，否則就不能正常工作。

9. 假設已知一個方法不會造成沖突，最明智的方法是不要使用synchronized，能提高些性能。

10 . 如果一個"同步"方法修改了一個變量，而我們的方法要用到這個變量(可能是只讀),最好將自己的這個方法也設為 synchronized。

11. synchronized不能繼承，　父類的方法是synchronized，那么其子類重載方法中就不會繼承“同步”。

12. 線程堵塞Blocked有幾個原因造成：

(1)線程在等候一些IO操作
(2)線程試圖調用另外一個對象的“同步”方法，但那個對象處于鎖定狀態，暫時無法使用。

13. 原子型操作(atomic), 對原始型變量(primitive)的操作是原子型的atomic. 意味著這些操作是線程安全的， 但是大部分情況下，我們并不能正確使用，來看看 i = i + 1 , i是int型，屬于原始型變量：

(1)從主內存中讀取i值到本地內存.
(2)將值從本地內存裝載到線程工作拷貝中.
(3)裝載變量1.
(4)將i 加 1.
(5)將結果給變量i.
(6)將i保存到線程本地工作拷貝中.
(7)寫回主內存.

注意原子型操作只限于第1步到第2步的讀取以及第6到第7步的寫, i的值還是可能被同時執行i=i+1的多線程中斷打擾(在第4步)。

double 和long 變量是非原子型的(non-atomic)。數組是object 非原子型。

14. 由于13條的原因，我們解決辦法是：

class xxx extends Thread{

//i會被經常修改
private int i;

public synchronized int read(){ return i;}

public synchronized void update(){ i = i + 1;}

..........

}

15. Volatile變量， volatile變量表示保證它必須是與主內存保持一致，它實際是"變量的同步", 也就是說對于volatile變量的操作是原子型的，如用在long 或 double變量前。

16. 使用yield()會自動放棄CPU，有時比sleep更能提升性能。

17. sleep()和wait()的區別是：wait()方法被調用時會解除鎖定，但是我們能使用它的地方只是在一個同步的方法或代碼塊內。

18. 通過制造縮小同步范圍，盡可能的實現代碼塊同步，wait(毫秒數)可在指定的毫秒數可退出wait；對于wait()需要被notisfy()或notifyAll()踢醒。

19. 構造兩個線程之間實時通信的方法分幾步：
(1). 創建一個PipedWriter和一個PipedReader和它們之間的管道;
PipedReader in = new PipedReader(new PipedWriter())
(2). 在需要發送信息的線程開始之前，將外部的PipedWriter導向給其內部的Writer實例out
(3). 在需要接受信息的線程開始之前，將外部的PipedReader導向給其內部的Reader實例in
(4). 這樣放入out的所有東西度可從in中提取出來。

20. synchronized帶來的問題除性能有所下降外，最大的缺點是會帶來死鎖DeadLock，只有通過謹慎設計來防止死鎖，其他毫無辦法，這也是線程難以馴服的一個原因。不要再使用stop() suspend() resume()和destory()方法

21. 在大量線程被堵塞時，最高優先級的線程先運行。但是不表示低級別線程不會運行，運行概率小而已。

22. 線程組的主要優點是：使用單個命令可完成對整個線程組的操作。很少需要用到線程組。

23. 從以下幾個方面提升多線程的性能：

檢查所有可能Block的地方，盡可能的多的使用sleep或yield()以及wait();

盡可能延長sleep(毫秒數)的時間;

運行的線程不用超過100個，不能太多；

不同平臺linux或windows以及不同JVM運行性能差別很大。

24. 推薦幾篇相關英文文章:

  /*
   * Classname
   *
   * Version information
   *
   * Date
   *
   * Copyright notice
   */
	  

  package java.awt;

  import java.awt.peer.CanvasPeer;
	  

  someMethod(longExpression1, longExpression2, longExpression3, 
                   longExpression4, longExpression5);

  var = someMethod1(longExpression1, 
                            someMethod2(longExpression2, 
                                               longExpression3));
	  

  longName1 = longName2 * (longName3 + longName4 - longName5)
                     + 4 * longname6; //PREFFER

  longName1 = longName2 * (longName3 + longName4 
                                         - longName5) + 4 * longname6; //AVOID
	  

  //CONVENTIONAL INDENTATION
  someMethod(int anArg, Object anotherArg, String yetAnotherArg, 
                    Object andStillAnother) {
    ...
  }

  //INDENT 8 SPACES TO AVOID VERY DEEP INDENTS
  private static synchronized horkingLongMethodName(int anArg,
          Object anotherArg, String yetAnotherArg,
          Object andStillAnother) {
    ...
  }
	  

  //DON’T USE THIS INDENTATION
  if ((condition1 && condition2)
      || (condition3 && condition4)
      ||!(condition5 && condition6)) { //BAD WRAPS
      doSomethingAboutIt();             //MAKE THIS LINE EASY TO MISS
  }

  //USE THIS INDENTATION INSTEAD
  if ((condition1 && condition2)
          || (condition3 && condition4)
          ||!(condition5 && condition6)) {
      doSomethingAboutIt();
  }

  //OR USE THIS
  if ((condition1 && condition2) || (condition3 && condition4)
          ||!(condition5 && condition6)) {
      doSomethingAboutIt();
  }
	  

  alpha = (aLongBooleanExpression) ? beta : gamma;

  alpha = (aLongBooleanExpression) ? beta
                                   : gamma;

  alpha = (aLongBooleanExpression)
          ? beta
          : gamma;
	  

  /*
   * Here is a block comment.
   */
	  

  /*-
    * Here is a block comment with some very special
    * formatting that I want indent(1) to ignore.
    *
    *    one
    *        two
    *            three
    */
	  

  if (condition) {

    /* Handle the condition. */
    ...
  }
	  

  if (a == 2) {
      return TRUE;              /* special case */
  } else {
      return isPrime(a);         /* works only for odd a */
  }
	  

  if (foo > 1) {

      // Do a double-flip.
      ...
  }
  else {
      return false;          // Explain why here.
  }

  //if (bar > 1) {
  //
  //    // Do a triple-flip.
  //    ...
  //}
  //else {
  //    return false;
  //}
	  

  /**
    * The Example class provides ...
    */
  public class Example { ...
	  

  int level;  // indentation level
  int size;   // size of table
	  

  int foo,  fooarray[];   //WRONG!
	  

  int		level;         // indentation level
  int		size;          // size of table
  Object	currentEntry;  // currently selected table entry
	  

  void myMethod() {
      int int1 = 0;         // beginning of method block

      if (condition) {
          int int2 = 0;     // beginning of "if" block
          ...
      }
  }
	  

  for (int i = 0; i < maxLoops; i++) { ... }
	  

  int count;
  ...
  myMethod() {
      if (condition) {
          int count = 0;     // AVOID!
          ...
      }
      ...
  }
	  

  class Sample extends Object {
      int ivar1;
      int ivar2;

      Sample(int i, int j) {
          ivar1 = i;
          ivar2 = j;
      }

      int emptyMethod() {}

      ...
  }
	  

  argv++;       // Correct
  argc--;       // Correct
  argv++; argc--;       // AVOID!
	  

  return;

  return myDisk.size();

  return (size ? size : defaultSize);
	  

  if (condition) {
      statements;
  }

  if (condition) {
      statements;
  } else {
      statements;
  }

  if (condition) {
      statements;
  } else if (condition) {
      statements;
  } else{
      statements;
  }
	  

  if (condition) //AVOID! THIS OMITS THE BRACES {}!
      statement;
	  

  for (initialization; condition; update) {
      statements;
  }
	  

  for (initialization; condition; update);
	  

  while (condition) {
      statements;
  }
	  

  while (condition);
	  

  do {
      statements;
  } while (condition);
	  

  switch (condition) {
  case ABC:
      statements;
      /* falls through */
  case DEF:
      statements;
      break;

  case XYZ:
      statements;
      break;

  default:
      statements;
      break;
  }
	  

  try {
      statements;
  } catch (ExceptionClass e) {
      statements;
  }
	  

  try {
      statements;
  } catch (ExceptionClass e) {
      statements;
  } finally {
      statements;
  }
	  

  while (true) {
      ...
  }
	  

    a += c + d;
    a = (a + b) / (c * d);

    while (d++ = s++) {
        n++;
    }
    printSize("size is " + foo + "\n");
	  

    for (expr1; expr2; expr3)
	  

    myMethod((byte) aNum, (Object) x);
    myMethod((int) (cp + 5), ((int) (i + 3)) + 1);
	  

  classMethod();             //OK
  AClass.classMethod();      //OK
  anObject.classMethod();    //AVOID!
	  

  fooBar.fChar = barFoo.lchar = 'c'; // AVOID!
	  

  if (c++ = d++) {        // AVOID! (Java disallows)
      ...
  }
	  

  if ((c++ = d++) != 0) {
    ...
  }
	  

  d = (a = b + c) + r;        // AVOID!
	  

  a = b + c;
  d = a + r;
	  

  if (a == b && c == d)     // AVOID!
  if ((a == b) && (c == d))  // RIGHT
	  

  if (booleanExpression) {
      return true;
  } else {
      return false;
  }
	  

  return booleanExpression;
	  

  if (condition) {
      return x;
  }
  return y;
	  

  return (condition ? x : y);
	  

  (x >= 0) ? x : -x;
	  

/*
 * @(#)Blah.java        1.82 99/03/18
 *
 * Copyright (c) 1994-1999 Sun Microsystems, Inc.
 * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
 * All rights reserved.
 *
 * This software is the confidential and proprietary information of Sun
 * Microsystems, Inc. ("Confidential Information").  You shall not
 * disclose such Confidential Information and shall use it only in
 * accordance with the terms of the license agreement you entered into
 * with Sun.
 */


package java.blah;

import java.blah.blahdy.BlahBlah;

/**
 * Class description goes here.
 *
 * @version 	1.82 18 Mar 1999
 * @author 	Firstname Lastname
 */
public class Blah extends SomeClass {
    /* A class implementation comment can go here. */

    /** classVar1 documentation comment */
    public static int classVar1;

    /**
     * classVar2 documentation comment that happens to be
     * more than one line long
     */
    private static Object classVar2;

    /** instanceVar1 documentation comment */
    public Object instanceVar1;

    /** instanceVar2 documentation comment */
    protected int instanceVar2;

    /** instanceVar3 documentation comment */
    private Object[] instanceVar3;

    /**
     * ...constructor Blah documentation comment...
     */
    public Blah() {
        // ...implementation goes here...
    }

    /**
     * ...method doSomething documentation comment...
     */
    public void doSomething() {
        // ...implementation goes here...
    }

    /**
     * ...method doSomethingElse documentation comment...
     * @param someParam description
     */
    public void doSomethingElse(Object someParam) {
        // ...implementation goes here...
    }
}
	  

請注意not in 邏輯上不完全等同于not exists，如果你誤用了not in，小心你的程序存在致命的BUG：

請看下面的例子：
create table t1 (c1 number,c2 number);
create table t2 (c1 number,c2 number);

insert into t1 values (1,2);
insert into t1 values (1,3);
insert into t2 values (1,2);
insert into t2 values (1,null);

select * from t1 where c2 not in (select c2 from t2);
no rows found
select * from t1 where not exists (select 1 from t2 where t1.c2=t2.c2);
c1 c2
1 3

正如所看到的，not in 出現了不期望的結果集，存在邏輯錯誤。如果看一下上述兩個select語句的執行計劃，也會不同。后者使用了hash_aj。
因此，請盡量不要使用not in(它會調用子查詢)，而盡量使用not exists(它會調用關聯子查詢)。如果子查詢中返回的任意一條記錄含有空值，則查詢將不返回任何記錄，正如上面例子所示。
除非子查詢字段有非空限制，這時可以使用not in ,并且也可以通過提示讓它使用hasg_aj或merge_aj連接。

public class PlatContextListener implements ServletContextListener{
??? private Timer timer = null;
??? /** 應用程序的根目錄 */
??? private static String contextPath = null;
???
??? /** Creates a new instance of PlatContextListener */
??? public PlatContextListener() {
??? }

??? public void contextInitialized(ServletContextEvent sce) {
??????? ServletContext sc = sce.getServletContext();
??????? contextPath = sc.getRealPath("").replace("\\", "/");
???????
??????? int nInterval=24*60*60*1000;
???????
??????? timer = new Timer(true);
???????
??????? //每天零晨3點執行清理工作
??????? Calendar calendar = Calendar.getInstance();
??????? calendar.set(Calendar.HOUR_OF_DAY,3);
??????? calendar.set(Calendar.MINUTE,0);
??????? calendar.set(Calendar.SECOND,0);
??????? Date time = calendar.getTime();
???
??????? timer.scheduleAtFixedRate(new PlatTimerClearTask(), time,nInterval);
???????

??? }

??? public void contextDestroyed(ServletContextEvent sce) {
??????? timer.cancel();
??? }
???
??? public static String getContextPath() {
??????? return contextPath;
??? }
???
}

在 IE6 中，可以很方便地利用 img 的 src 屬性，實現本地圖片預覽，然而在 IE7 中，這種辦法卻行不通。需要用 AlphaImageLoader。

---

AlphaImageLoader

說明：

在對象容器邊界內，在對象的背景和內容之間顯示一張圖片。并提供對此圖片的剪切和改變尺寸的操作。如果載入的是PNG(Portable Network Graphics)格式，則0%-100%的透明度也被提供。

語法：

filter : progid:DXImageTransform.Microsoft.AlphaImageLoader ( enabled=bEnabled , sizingMethod=sSize , src=sURL )

enabled：可選項。布爾值(Boolean)。設置或檢索濾鏡是否激活。
true：默認值。濾鏡激活。
false：濾鏡被禁止。

sizingMethod：可選項。字符串(String)。設置或檢索濾鏡作用的對象的圖片在對象容器邊界內的顯示方式。
crop：剪切圖片以適應對象尺寸。
image：默認值。增大或減小對象的尺寸邊界以適應圖片的尺寸。
scale：縮放圖片以適應對象的尺寸邊界。

src：必選項。字符串(String)。使用絕對或相對 url 地址指定背景圖像。假如忽略此參數，濾鏡將不會作用。

---

具體操作：

1. 為預覽區域（比如要在某個?div 中預覽）添加樣式：filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(sizingMethod=scale);。
2. 為 AlphaImageLoader 設置 src 屬性。

---

?

示例代碼：

<? xml?version="1.0"?encoding="gb2312" ?>
<! DOCTYPE?html?PUBLIC?"-//W3C//DTD?XHTML?1.0?Transitional//EN"?"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" >
< html? xmlns ="http://www.w3.org/1999/xhtml" >

< head >
< meta? http-equiv ="Content-Type" ?content ="text/html;?charset=gb2312" ? />
< title > 本地圖片預覽代碼（支持?IE6、IE7） </ title >
< style? type ="text/css" >
#newPreview
{} {
????filter : progid:DXImageTransform.Microsoft.AlphaImageLoader(sizingMethod=scale) ;
}
</ style >
< script? type ="text/javascript" ?language ="javascript" >
<!--
function ?PreviewImg(imgFile)
{
???? // 原來的預覽代碼，不支持?IE7。
???? var ?oldPreview? = ?document.getElementById( " oldPreview " );
????oldPreview.innerHTML? = ? " <img?src=\ " file:\\\\ " ?+?imgFile.value?+? " \ " ?width=\ " 80 \ " ?height=\ " 60 \ " ?/> " ;
????
???? // 新的預覽代碼，支持?IE6、IE7。
???? var ?newPreview? = ?document.getElementById( " newPreview " );
????newPreview.filters.item( " DXImageTransform.Microsoft.AlphaImageLoader " ).src? = ?imgFile.value;
????newPreview.style.width? = ? " 80px " ;
????newPreview.style.height? = ? " 60px " ;
}
-->
</ script >
</ head >

< body >

< p > 說明：以下針對的是互聯網情況，如果您在本地作測試，比如輸入的地址是：http://127.0.0.1/，則可以看到全部預覽。 </ p >

< hr? />

< p > 如果您使用的是?IE6，則可以看到以下預覽；如果您使用的是?IE7，則看不到以下預覽。 </ p >
< div? id ="oldPreview" ></ div >

< hr? />

< p > 不論您使用的是?IE6?還是?IE7，均可以看到以下預覽。 </ p >
< div? id ="newPreview" ></ div >

< hr? />

< p > 請選擇一個圖片進行預覽： < input? type ="file" ?size ="20" ?onchange ="javascript:PreviewImg(this);" ? /></ p >

</ body >

</ html >

異常控制

??Author: 江南白衣

1.業務異常類

????? 1.所以業務異常類派生于BusinessException基類。

????? 2.原則上，要進行相同處理的異常分為一類，用ERROR_CODE標識不同。

????? 3.出錯信息統一寫在errors.properties，以ERROR_CODE為主鍵，支持i18N，由基類提供默認的getMessage()函數。

????? 參考BussinessException.java和OrderException.java。

2.Servlet規范里的異常控制

?2.1按error-code統一定義錯誤頁面

<error-page>
? <error-code>404</error-code>
? <location>/404.jsp</location>
</error-page>

<error-page>
? <error-code>500</error-code>
? <location>/error.jsp</location>
</error-page>

2.2按異常類型定義單獨錯誤頁面

<error-page>
? <exception-type>org.sprngside.bookstore.UserNotFound</exception-type>
? <location>/userNotFound.jsp</location>
</error-page>

2.3 在JSP里單獨定義錯誤頁面

<@ errorPage="error.jsp">

3.Spring MVC里的異常控制

?? spring-mvc可在xxx-serverlet.xml里定義default和 按Excepiton類型影射的錯誤頁面, 和Servlet規范比,主要作了Spring特色的JSP路徑轉向和日志記錄.參見bookstore-servlet.xml

  <bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
??????? <property name="defaultErrorView" value="/error.jsp"/>
??????? <property name="exceptionMappings">
??????????? <props>
??????????????? <prop key="org.springside.framework.base.BusinessException">/businessError.jsp</prop>
??????????? </props>
??????? </property>
??? </bean>

4. error.jsp的處理

???????? error.jsp會同時處理jsp,servlet,和spring拋過來的異常

???????? 其中jsp的異常在exception 變量中.

???????? servlet的異常在(Exception)request.getAttribute("javax.servlet.error.exception")

???????? spring的異常在(Exception) request.getAttribute("exception")

???????? 使用 (String) request.getAttribute("javax.servlet.error.request_uri")獲得 request_uri
?????????使用 logger.error(exception.getMessage(), exception); 記錄整個異常棧

java.lang.Objectorg.acegisecurity.util.FilterChainProxy

All Implemented Interfaces:

Filter, InitializingBean, ApplicationContextAware

public class FilterChainProxy
extends Object
implements Filter, InitializingBean, ApplicationContextAware

Delegates Filter requests to a list of Spring-managed beans.

通過一系列的由spring托管的beans ，代理過濾請求。
FilterChainProxy 通過在web.xml中定義的FilterToBeanProxy 被加載，FilterChainProxy 將會通過init(FilterConfig), destroy() and doFilter(ServletRequest, ServletResponse, FilterChain)調用，調用每一個在其中定義的過濾器。

The FilterChainProxy is loaded via a standard FilterToBeanProxy declaration in web.xml. FilterChainProxy will then pass init(FilterConfig), destroy() and doFilter(ServletRequest, ServletResponse, FilterChain) invocations through to each Filter defined against FilterChainProxy.

?
??? FilterChainProxy? 是通過一個標準的FilterInvocationDefinitionSource 來實現配置的，每個可能的FilterChainProxy應該服務的URI模式都必須進入
??????????? 第一個搭配的URI模式將會被用來定義處理請求的所有的過濾器，就是說只適配第一組過濾器，后面的其他過濾器將無效。
FilterChainProxy is configured using a standard FilterInvocationDefinitionSource. Each possible URI pattern that FilterChainProxy should service must be entered. The first matching URI pattern located by FilterInvocationDefinitionSource for a given request will be used to define all of the Filters that apply to that request. NB: This means you must put most specific URI patterns at the top of the list, and ensure all Filters that should apply for a given URI pattern are entered against the respective entry. The FilterChainProxy will not iterate the remainder of the URI patterns to locate additional Filters. The FilterInvocationDefinitionSource described the applicable URI pattern to fire the filter chain, followed by a list of configuration attributes. Each configuration attribute's ConfigAttribute.getAttribute() corresponds to a bean name that is available from the application context.

FilterChainProxy respects normal handling of Filters that elect not to call Filter.doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse, javax.servlet.FilterChain), in that the remainder of the origial or FilterChainProxy-declared filter chain will not be called.

It is particularly noted the Filter lifecycle mismatch between the servlet container and IoC container. As per FilterToBeanProxy JavaDocs, we recommend you allow the IoC container to manage lifecycle instead of the servlet container. By default the FilterToBeanProxy will never call this class' init(FilterConfig) and destroy() methods, meaning each of the filters defined against FilterInvocationDefinitionSource will not be called. If you do need your filters to be initialized and destroyed, please set the lifecycle initialization parameter against the FilterToBeanProxy to specify servlet container lifecycle management.

If a filter name of TOKEN_NONE is used, this allows specification of a filter pattern which should never cause any filters to fire.

四?Acegi ACL使用?

4.1 基本概念

????? 在google中搜索'acl'會找到很多相關的介紹，而且涉及的范圍也特別廣泛。ACL是(Access Control List)的縮寫，顧名思義，ACL是‘訪問控制列表’的意思。通俗點說，ACL保存了所有用戶或角色對資源的訪問權限。最典型的ACL實現是流行操作系統(window, unix)的文件訪問控制系統，精確定義了某個用戶或角色對某個特定文件的讀、寫、執行等權限，更通俗的例子是可以定義某個管理員只能管一部分的訂單，而另一個管理員只能管另一部分的。

4.2 Acegi ACL配置

Acegi好早就實現了ACL（好像是0.5），但是使用起來確實有點麻煩，所以用的不是太廣泛。這里簡單的說明一下使用方法，希望有更多的朋友來試試。

首先要理解Acegi里面Voter的概念，ACL正是在一個Voter上擴展起來的。現來看一下AclVoter的配置。

1. ACL_READ指的是這個Voter對哪些SecurityConfig起作用，我們可以把ACL_READ配置在想要攔截的Method上。比方說我們要攔截readOrder這個方法，以實現ACL控制，可以這樣配置。
   orderManager.readOrder=ACL_READ
2. processDomainObjectClass指出哪些DomainObject是要進行ACL校驗的。
3. aclManager是一個比較重要的概念，主要負責在權限列表中根據用戶和DomainObject取得acl列表。
4. requirePermission指出要進行這個操作必須具備的acl權限，比方說read操作就必須有ADMINISTRATION或READ兩個權限。

其實整個過程看下來比較清晰，下面來看一下AclManager如何配置。

很明顯ACLManager繼承了Acegi的一貫風格，Provider可以提供多種取得ACL訪問列表的途徑，默認的是用basicAclProvider在數據庫中取得。既然提到了數據庫，那我們就來看一下Acegi默認提供的ACL在數據庫里的保存表結構：

1. acl_object_identity表存放了所有受保護的domainObject的信息。其中object_identity字段保存了domainObject的class和id，默認的保存格式是：domainClass:domainObjectId。
2. acl_permission?就是ACL權限列表了，recipient?是用戶或角色信息，mask表示了這個用戶或角色對這個domainObject的訪問權限。注意這些信息的保存格式都是可以根據自己的需要改變的。

這樣讀取和刪除的時候Acegi就能很好的完成攔截工作，但是讀取一個List的時候，如何才能把該用戶不能操作的domainObject剔除掉呢？這就需要afterInvocationManager來完成這個工作。下面來看下配置：

afterAclCollectionRead會在攔截的方法執行結束的時候執行。主要的作用就是在返回的List中挨個檢查domainObject的操作權限，然后根據requirePermission來剔除不符合的domainObject。

4.3 使用RuleEngine設置的ACL規則

在SpringSide里使用了RuleEngine來設置ACL規則，具體規則見
bookstore-sample\resources\rules\drl