lsbwahaha

最近有Java解壓縮的需求，java.util.zip實在不好用，對中文支持也不行。所以選擇了強大的TrueZIP，使用時遇到了一個問題，做個記錄。
解壓縮代碼如下：

ArchiveDetector detector = new DefaultArchiveDetector(ArchiveDetector.ALL,

        new Object[] { "zip", new CheckedZip32Driver("GBK") } );

File zipFile = new File("zipFile", detector);

File dst = new File("dst");

// 解壓縮

zipFile.copyAllTo(dst);

代碼十分簡潔，注意這個File是

de.schlichtherle.io.File

不是

java.io.File

當處理完業(yè)務要刪除這個Zip File時，問題出現(xiàn)了：
這個文件刪不掉?。?！
把自己的代碼檢查了好久，確認沒問題后，開始從TrueZIP下手，發(fā)現(xiàn)它有特殊的地方的，是提示過的：

File file = new File(“archive.zip”); // de.schlichtherle.io.File!
Please do not do this instead:
de.schlichtherle.io.File file = new de.schlichtherle.io.File(“archive.zip”);

This is for the following reasons:
1.Accidentally using java.io.File and de.schlichtherle.io.File instances referring to the same path concurrently will result in erroneous behaviour and may even cause loss of data! Please refer to the section “Third Party Access” in the package Javadoc of de.schlichtherle.io for for full details and workarounds.
2.A de.schlichtherle.io.File subclasses java.io.File and thanks to polymorphism can be used everywhere a java.io.File could be used.

原來兩個File不能交叉使用，搞清楚原因了，加這么一句代碼搞定。

zipFile.deleteAll();

目前的ANTLR支持的語法層的選項主要包括：

語言選項（Language）、

輸出選項（output）、

回溯選項（backtrack）、

記憶選項 （memorize）、

記號詞庫（tokenVocab）、

重寫選項（rewrite）、

超類選項（superClass）、

過濾選項（Filter）、

AST標簽類型（ASTLabelType）

K選項

/**

        //一些寫法















k=2;

        backtrack=true;

        memoize=true;

*/

1.   語言選項 language

語言選項指定了ANTLR將要產(chǎn)生的代碼的目標語言，默認情況下該選項設置為了Java。需要注意的是，ANTLR中的嵌入的動作必須要使用目標語言來寫。

grammar T;
options {
    language=Java;
}

ANTLR使用了特有的基于字串模板（StringTemplate-based）代碼生成器，構建一個新的目標語言顯得較為簡單，因此我們可以構建多種 語言，諸如Java，C，C++，C#，Python，Objective-C，Ruby等等。語言選項讓ANNTLR去模板目錄（例如 org/antlr/codegen/templates/Java or org/antlr/codegen/templates/C）下尋找合適的模板,并使用模板來構建語言。該目錄下包含大量的模板，我們可以向其中加入其 他的模板以滿足我們的需求。

2.   輸出選項 output

輸出選項控制了ANTLR輸出的數(shù)據(jù)結構，目前支持兩種輸出：抽象語法樹——AST（Abstract Syntax Trees）和字串模板（StringTemplates）——template。當output這個選項被設置后，所有的規(guī)則都被輸出成了AST或者 template。

grammar T;
options {
    output=AST;
}

3.   回溯選項backtrack

當回溯選項打開的時候，在執(zhí)行一個LL(K)失敗的時候，ANTLR會返回至LL(K)開始而嘗試其他的規(guī)則。

4.   記憶選項 （memorize）

memoize選項打開以后，每條解析方法（Paser Method）開始之前，ANTLR會首先檢測以前的嘗試結果，并在該方法執(zhí)行完成之后記錄該規(guī)則是否執(zhí)行成功。但是注意，對于單條的規(guī)則打開此選項經(jīng)常比在全局上打開該規(guī)則效率更高。

5.   記號詞庫（tokenVocab）

說白了就是output輸出目錄中的XX.tokens文件中的定義可以方便的給 大型工程中多個.g中的符號同步更新。

大型的工程中常常利用AST作為中間產(chǎn)物對輸入進行多次分析并最終生成代碼。對AST的遍歷時需要經(jīng)常使用樹語法（tree grammar），而tree grammar中經(jīng)常需要將符號與其他的文件中的符號進行同步或者更新。tokenVocab實現(xiàn)了這個功能。
例如我們定義了下面的一個語法文件：

grammar P;
options {
    output=AST;
}
expr: INT ('+' ^ INT)* ;
INT : '0'..'9' +;
WS : ' ' | '\r' | '\n' ;
利用該文件生成了一個標記：P.token，并生成了語法樹（AST）。這時我們需要一個用于遍歷該AST的tree grammar，并通過tree grammar 中的tokenVocab選項來向其中更新tokens:

tree grammar Dump;
options {
    tokenVocab=P;
    ASTLabelType=CommonTree;
}
expr: ^( '+' expr {System.out.print('+' );} expr )
    | INT {System.out.print($INT.text);}
    ;

編譯tree grammar的時候ANTLR默認會在當前目錄下尋找.token文件，我們可以通過-lib選項來設置用于尋找.token文件的目錄，例如：
java org.antlr.Tool -lib . Dump.g

6.   重寫選項（rewrite）

通過重寫選項可以改變ANTLR對輸入的默認處理規(guī)則，一般用在輸出為template的情況下。將該選項使能之后，ANTLR將一般的輸入直接拷貝至輸出，而將適于模板重寫規(guī)則的輸入做其他的處理。

7.   超類選項（superClass）

用于指定一個超類。

8.   過濾選項（Filter）

9.   AST標簽類型（ASTLabelType）

10.             K選項

   K選項用于限制對LL(K)進行語法分析的次數(shù)，從而提高了ANTLR的解析速度。K只能為*或者數(shù)字，默認為*。

屬性和動作

動作（Actions）實際上是用目標語言寫成的、嵌入到規(guī)則中的代碼（以花括號包裹）。它們通常直接操作輸入的標號，但是他們也可以用來調用相應的外部代碼。屬性，到目前為止我的理解還不多，感覺像是C++中類里面的成員，一會看完應該會更清楚一些。

1. 語法動作（Grammar Actions）
動作（Actions）是指嵌在語法中的、用目標語言寫成的代碼片段。ANTLR則把這些代碼（除了用$或%標記的以外）逐字地插入到生成的識別器中。
動作可以放到規(guī)則的外邊，也可以嵌入到某條規(guī)則當中。當動作位于規(guī)則之外時候，這些動作同城定義了一些全局的或者是類的成員（變量或者成員函數(shù)）；而當其嵌入規(guī)則之中時，則用于執(zhí)行某些特定的命令，這些命令在識別器識別了其預訂的字符的時候就會開始執(zhí)行。例如下面的例子：

parser grammar T;
@header {
    package p;
}
@members {
    int i;
    public TParser(TokenStream input, int foo) {
        this(input);
        i = foo;
    }
}
a[int x] returns [int y]
@init {int z=0;}
@after {System.out.println("after matching rule; before finally");}
: {《action1》} A {《action2 》}
;
catch[RecognitionException re] {
    System.err.println("error");
}
finally { 《do-this-no-matter-what 》 }

從中可以看出，前面的兩個動作，@head and @members是兩個處于規(guī)則之外的全局的動作，定義了一些變量和類；而后兩個則分別在a這個規(guī)則的前后執(zhí)行（@init在前，@after在后，這個在前面提到過）。 這里針對兩種類型詳細敘述。

       在傳統(tǒng)的項目中，通常有一個人保護他們的代碼庫，直到代碼集成階段。但是在敏捷里面，我們持代碼集體所有制的觀點——所有的代碼屬于所有的開發(fā)人員，只要開發(fā)人員認為有必要，每個人都能不受約束地去改善代碼。在一段時間里面，我們的代碼庫開始出現(xiàn)奇怪的行為——解決辦法就是重構（感謝Martin Fowler在他的同名著作中把重構一詞推廣開來）。重構的本質歸結為修改代碼以改善代碼的結構和清晰度，但不改變代碼的功能。我們學到的一個重要教訓是在重構代碼之前使用單元測試作為安全網(wǎng)，我們曾經(jīng)使用過的一些主要工具包括Eclipse、NetBeans、IntelliJ IDEA的和Visual Studio.NET。

在敏捷團隊之中工作所必備的行為特征

由于敏捷團隊不同于普通的團隊，并且非常倚賴于有效果和有效率的溝通和快速執(zhí)行，敏捷團隊更需要使用軟技能。如果我們意識到這一點，并積極鼓勵使用這些特征和技能，我們可以使得敏捷團隊更有價值和富有成效。

自組織往往倚賴于諸如正反饋、負反饋、深度探索和廣度調研之間取得平衡以及多重互動的基本要素。根據(jù)我們的經(jīng)驗，團隊可能由于許多文化和社會因素無法給予正確的反饋或者回避人與人之間的互動。

根據(jù)我個人的經(jīng)驗，這仍然是一個“神話”。我們總是傾向于患有“可預測性綜合癥”——如果我們做更多的規(guī)劃，我們將更加功能預測。

團隊需要有良好的紀律、有能力承擔責任、盡忠盡責以及承擔職責和所有權。

團隊需要擁有的關鍵技能之一是有能力尋求幫助，并尋求他人的評價。在某些情形下，我們已經(jīng)看到了“自我”因素表現(xiàn)為一個主要的障礙。

有些時候，承擔責任，盡忠盡責和協(xié)作精神是理所當然的，但是根據(jù)以往的經(jīng)驗，為了這些能夠出現(xiàn)，我們有時需要外部干預。

有些我們常常傾向于忽視的關鍵技能是積極主動、在激烈的環(huán)境中享受工作和易于適應新的形勢和框架。

我們的大多數(shù)項目都是分布式的，這意味著在客戶和服務供應商之間將會共同使用Scrum。在這種情況下，諸如管理多樣化團隊、時間管理、外交技巧和領導力等技能是非常關鍵的。

敏捷團隊的成功“咒語”

對于任何一個希望成功和高效的敏捷項目，團隊需要對向同儕學習（不管資歷和專業(yè)知識）表現(xiàn)出更大的熱情和正確的態(tài)度。必須保證一個無畏表達的安全網(wǎng)，這樣才會展現(xiàn)出真正的友情，而這反過來會增強團隊成員對團隊目標的關注，而不是“哪些由我來做”？

結論

根據(jù)我個人的經(jīng)驗和觀察，對于提高生產(chǎn)率所需的技能，敏捷項目與傳統(tǒng)項目有所不同。本文定義了團隊提高生產(chǎn)率所需的行為和技術技能。具有這些“delta” 特征的人應該具備了合適的行為和技術技能，這些技能使得他們在敏捷項目中的工作能夠富有成效。對于這些技能的總結請見下表。

技能表

作者簡介

Prasad，擁有10年的IT服務行業(yè)經(jīng)驗，他第一次接觸敏捷項目是在2005年微軟的一個項目；從那時起，他為許多公司如GE、思科、可口可樂等，針對敏捷及其變體提供了解決方案開發(fā)、培訓、咨詢以及指導。目前他正在Symphony Services的敏捷實驗室擔任經(jīng)理。Symphony40％的項目都是關于敏捷或其不同的形式，并且自2004年起就通過敏捷為客戶提供商務的關鍵價值。你可以通過pprabhak@symphonsysv.com與他聯(lián)系。

查看英文原文：Skills for Scrum Agile Teams

1. 任何程序一旦部署即顯陳舊。
2. 修改需求規(guī)范來適應程序比反過來做更容易。
3. 一個程序如果很有用，那它注定要被改掉。
4. 一個程序如果沒用，那它一定會有很好的文檔。
5. 任何程序里都僅僅只有10%的代碼會被執(zhí)行到。
6. 軟件會一直膨脹到耗盡所有資源為止。
7. 任何一個有點價值的程序里都會有至少一個bug。
8. 原型完美的程度跟審視的人數(shù)成反比，反比值會隨著涉及的資金數(shù)增大。
9. 軟件直到被變成產(chǎn)品運行至少6個月后，它最嚴重的問題才會被發(fā)現(xiàn)。
10. 無法檢測到的錯誤的形式無限多樣，而能被檢測到的正好相反，被定義了的十分有限。
11. 修復一個錯誤所需要投入的努力會隨著時間成指數(shù)級增加。
12. 軟件的復雜度會一直增加，直到超出維護這個程序的人的承受能力。
13. 任何自己的程序，幾個月不看，形同其他人寫的。
14. 任何一個小程序里面都有一個巨大的程序蠢蠢欲出。
15. 編碼開始的越早，花費的時間越長。
16. 一個粗心的項目計劃會讓你多花3倍的時間去完成；一個細心的項目計劃只會讓你多花2倍的時間。
17. 往大型項目里添加人手會使項目更延遲。
18. 一個程序至少會完成90%，但永遠完成不了超過95%。
19. 如果你想麻煩被自動處理掉，你得到的是自動產(chǎn)生的麻煩。
20. 開發(fā)一個傻瓜都會使用的軟件，只有傻瓜愿意使用它。
21. 用戶不會真正的知道要在軟件里做些什么，除非使用過。

public class CheckQueryParams {

    private static interface Validation{
 void check(QueryInfo query);
    }
   
    private static List<Validation> validations = new ArrayList<Validation>();
   
    static {
 validations.add(new Validation() {
     public void check(QueryInfo query) {
  if(StringUtils.isEmpty(query.getStartKey()) && StringUtils.isEmpty(query.getEndKey()))
      throw new RuntimeException("Both keys can not be null or empty at the same time");
     }});
    }

    public static void check(QueryInfo query) {
 for(Validation validation : validations) {
     validation.check(query);
 }
    }
}

public class LRUCache<K,V> {

    final private int capacity;
    final private Map<K,Reference<V>> map;
    final private ReentrantLock lock = new ReentrantLock();
    final private ReferenceQueue<Reference<V>> queue = new ReferenceQueue<Reference<V>>();
   
    public LRUCache(int capacity) {
 this.capacity = capacity;
 map = new LinkedHashMap<K,Reference<V>>(capacity,1f,true){
     @Override
     protected boolean removeEldestEntry(Map.Entry<K,Reference<V>> eldest) {
         return this.size() > LRUCache.this.capacity;
     }
 };
    }
   
    public V put(K key,V value) {
 lock.lock();
 try {
  map.put(key, new SoftReference(value,queue));
  return value;
 }finally {
     lock.unlock();
 }
    }
   
    public V get(K key) {
 lock.lock();
 try {
     queue.poll();
     return map.get(key).get();
 }finally {
     lock.unlock();
 }
    }
 
    public void remove(K key) {
 lock.lock();
 try {
     map.remove(key);
 }finally {
     lock.unlock();
 }
    }

}

         java中的同步對象，實際上是對于reference所指的“對象地址”進行同步。
        需要注意的問題是，千萬不要對同步對象重新賦值。舉個例子。
            class A implements Runnable{
                Object lock = new Object();

                    void run(){
                        for(...){
                            synchronized(lock){
                                // do something
                                    ...
                                  lock = new Object();
                             }
                        }
                    }
            }

        run函數(shù)里面的這段同步代碼實際上是毫無意義的。因為每一次lock都給重新分配了新的對象的reference，每個線程都在新的reference同步。大家可能覺得奇怪，怎么會舉這么一個例子。因為我見過這樣的代碼，同步對象在其它的函數(shù)里被重新賦了新值。這種問題很難查出來。所以，一般應該把同步對象聲明為final。 final Object lock = new Object();

使用Singleton Pattern 設計模式來獲取同步對象，也是一種很好的選擇。

        實現(xiàn)線程，有兩種方法，一種是繼承Thread類，一種是實現(xiàn)Runnable接口。
        首先，把需要共享的數(shù)據(jù)放在一個實現(xiàn)Runnable接口的類里面，然后，把這個類的實例傳給多個Thread的構造方法。這樣，新創(chuàng)建的多個Thread，都共同擁有一個Runnable實例，共享同一份數(shù)據(jù)。如果采用繼承Thread類的方法，就只好使用static靜態(tài)成員了。如果共享的數(shù)據(jù)比較多，就需要大量的static靜態(tài)成員，令程序數(shù)據(jù)結構混亂，難以擴展。這種情況應該盡量避免。編寫一段多線程代碼，處理一個稍微復雜點的問題。兩種方法的優(yōu)劣，一試便知。

        線程同步的粒度越小越好，即，線程同步的代碼塊越小越好。盡量避免用synchronized修飾符來聲明方法。盡量使用synchronized(anObject)的方式，如果不想引入新的同步對象，使用synchronized(this)的方式。而且，synchronized代碼塊越小越好。

        對于簡單的問題，可以把訪問共享資源的同步代碼都放在一個類里面。
        但是對于復雜的問題，我們需要把問題分為幾個部分來處理，需要幾個不同的類來處理問題。這時，就需要在不同的類中，共享同步對象。比如，在生產(chǎn)者和消費者之間共享同步對象，在讀者和寫者之間共享同步對象。
如何在不同的類中，共享同步對象。有幾種方法實現(xiàn)，
（1）前面講過的方法，使用static靜態(tài)成員，（或者使用Singleton Pattern.）
（2）用參數(shù)傳遞的方法，把同步對象傳遞給不同的類。
（3）利用字符串常量的“原子性”。
對于第三種方法，這里做一下解釋。一般來說，程序代碼中的字符串常量經(jīng)過編譯之后，都具有唯一性，即，內存中不會存在兩份相同的字符串常量。
（通常情況下，C++，C語言程序編譯之后，也具有同樣的特性。）

    比如，我們有如下代碼。
        String A = “atom”;
        String B = “atom”;

    我們有理由認為，A和B指向同一個字符串常量。即，A==B。注意，聲明字符串變量的代碼，不符合上面的規(guī)則。
        String C= new String(“atom”);
        String D = new String(“atom”);
    這里的C和D的聲明是字符串變量的聲明，所以，C != D。

有了上述的認識，我們就可以使用字符串常量作為同步對象。比如我們在不同的類中，使用synchronized(“myLock”), “myLock”.wait(),“myLock”.notify(), 這樣的代碼，就能夠實現(xiàn)不同類之間的線程同步。本文并不強烈推薦這種用法，只是說明，有這樣一種方法存在。本文推薦第二種方法，（2）用參數(shù)傳遞的方法，把同步對象傳遞給不同的類。