Tapestry [7]提供了一個分布式容錯查找和路由基礎(chǔ)平臺，在此平臺基礎(chǔ)之上，可以開發(fā)各種P2P應(yīng)用(OceanStore[8]即是此平臺上的一個應(yīng)用)。Tapestry的思想來源于Plaxton。在Plaxton中，結(jié)點使用自己所知道的鄰近結(jié)點表，按照目的ID來逐步傳遞消息。Tapestry基于Plaxton的思想，加入了容錯機(jī)制，從而可適應(yīng)P2P的動態(tài)變化的特點。OceanStore是以Tapestry為路由和查找基礎(chǔ)設(shè)施的P2P平臺。它是一個適合于全球數(shù)據(jù)存儲的P2P應(yīng)用系統(tǒng)。任何用戶均可以加入OceanStore系統(tǒng)，或者共享自己的存儲空間，或者使用該系統(tǒng)中的資源。通過使用復(fù)制和緩存技術(shù)，OceanStore可提高查找的效率。最近，Tapestry為適應(yīng)P2P網(wǎng)絡(luò)的動態(tài)特性，作了很多改進(jìn)，增加了額外的機(jī)制實現(xiàn)了網(wǎng)絡(luò)的軟狀態(tài)（soft state），并提供了自組織、魯棒性、可擴(kuò)展性和動態(tài)適應(yīng)性，當(dāng)網(wǎng)絡(luò)高負(fù)載且有失效結(jié)點時候性能有限降低，消除了對全局信息的依賴、根結(jié)點易失效和彈性差的問題。

Pastry 是微軟研究院提出的可擴(kuò)展的分布式對象定位和路由協(xié)議，可用于構(gòu)建大規(guī)模的P2P系統(tǒng)。如圖3 所示，在Pastry中，每個結(jié)點分配一個128位的結(jié)點標(biāo)識符號(nodeID) ，所有的結(jié)點標(biāo)識符形成了一個環(huán)形的nodeID空間，范圍從0到2128 - 1 ，結(jié)點加入系統(tǒng)時通過散列結(jié)點IP地址在128位nodeID空間中隨機(jī)分配。網(wǎng)絡(luò)結(jié)點的加入與退出，資源查詢的過程可以參考文獻(xiàn)[9]。

圖3Pastry的消息路由

Chord [10]項目誕生于美國的麻省理工學(xué)院。它的目標(biāo)是提供一個適合于P2P環(huán)境的分布式資源發(fā)現(xiàn)服務(wù)，它通過使用DHT技術(shù)使得發(fā)現(xiàn)指定對象只需要維護(hù)O(logN)長度的路由表。在DHT技術(shù)中，網(wǎng)絡(luò)結(jié)點按照一定的方式分配一個唯一結(jié)點標(biāo)識符(Node ID) ，資源對象通過散列運(yùn)算產(chǎn)生一個唯一的資源標(biāo)識符(Object ID) ，且該資源將存儲在結(jié)點ID與之相等或者相近的結(jié)點上。需要查找該資源時，采用同樣的方法可定位到存儲該資源的結(jié)點。因此，Chord的主要貢獻(xiàn)是提出了一個分布式查找協(xié)議，該協(xié)議可將指定的關(guān)鍵字(Key) 映射到對應(yīng)的結(jié)點(Node) 。從算法來看，Chord是相容散列算法的變體。

圖4 Chord的拓?fù)湫螤?/p>

CAN(Content Addressable Networks)[11] 項目采用多維的標(biāo)識符空間來實現(xiàn)分布式散列算法。CAN將所有結(jié)點映射到一個n維的笛卡爾空間中，并為每個結(jié)點盡可能均勻的分配一塊區(qū)域。CAN采用的散列函數(shù)通過對(key, value) 對中的key進(jìn)行散列運(yùn)算，得到笛卡爾空間中的一個點，并將(key, value) 對存儲在擁有該點所在區(qū)域的結(jié)點內(nèi)。CAN采用的路由算法相當(dāng)直接和簡單，知道目標(biāo)點的坐標(biāo)后，就將請求傳給當(dāng)前結(jié)點四鄰中坐標(biāo)最接近目標(biāo)點的結(jié)點。CAN是一個具有良好可擴(kuò)展性的系統(tǒng)，給定N個結(jié)點，系統(tǒng)維數(shù)為d，則路由路徑長度為O(n1/d) ，每結(jié)點維護(hù)的路由表信息和網(wǎng)絡(luò)規(guī)模無關(guān)為O(d) 。

上述四種基于DHT的P2P系統(tǒng)的性能比較可以參照[12]。DHT這類結(jié)構(gòu)最大的問題是DHT的維護(hù)機(jī)制較為復(fù)雜，尤其是結(jié)點頻繁加入退出造成的網(wǎng)絡(luò)波動（Churn）會極大增加DHT的維護(hù)代價。DHT所面臨的另外一個問題是DHT僅支持精確關(guān)鍵詞匹配查詢，無法支持內(nèi)容/語義等復(fù)雜查詢。

半分布式拓?fù)浣Y(jié)構(gòu)（有的文獻(xiàn)亦稱作混雜模式，英文表達(dá)為Hybrid Structure）吸取了中心化結(jié)構(gòu)和全分布式非結(jié)構(gòu)化拓?fù)涞膬?yōu)點，選擇性能較高（處理、存儲、帶寬等方面性能）的結(jié)點作為超級結(jié)點（英文表達(dá)為SuperNodes或者Hubs），在各個超級結(jié)點上存儲了系統(tǒng)中其他部分結(jié)點的信息，發(fā)現(xiàn)算法僅在超級結(jié)點之間轉(zhuǎn)發(fā)，超級結(jié)點再將查詢請求轉(zhuǎn)發(fā)給適當(dāng)?shù)娜~子結(jié)點。半分布式結(jié)構(gòu)也是一個層次式結(jié)構(gòu)，超級結(jié)點之間構(gòu)成一個高速轉(zhuǎn)發(fā)層，超級結(jié)點和所負(fù)責(zé)的普通結(jié)點構(gòu)成若干層次。采用這種結(jié)構(gòu)的最典型的案例就是KaZaa。

圖5 半分布式拓?fù)浣Y(jié)構(gòu)（網(wǎng)絡(luò)中包含Super Node）

KaZaa是當(dāng)前世界最流行的幾款P2P文件共享軟件之一。根據(jù)CA公司統(tǒng)計，全球KaZaa的下載量超過2.5億次。使用KaZaa軟件進(jìn)行文件傳輸消耗了互聯(lián)網(wǎng)40%的帶寬。之所以它如此的成功，是因為它結(jié)合了Napster和Gnutella共同的優(yōu)點。從結(jié)構(gòu)上來說，它使用了Gnutella的全分布式的結(jié)構(gòu)，這樣可以是系統(tǒng)更好的擴(kuò)展，因為它無需中央索引服務(wù)器存儲文件名，它是自動的把性能好的機(jī)器成為SuperNode，它存儲著離它最近的葉子節(jié)點的文件信息，這些SuperNode,再連通起來形成一個Overlay Network. 由于SuperNode的索引功能，使搜索效率大大提高。

圖6 KaZaa的軟件界面

半分布式結(jié)構(gòu)的優(yōu)點是性能、可擴(kuò)展性較好，較容易管理，但對超級點依賴性大，易于受到攻擊，容錯性也受到影響。

在實際應(yīng)用中，每種拓?fù)浣Y(jié)構(gòu)的P2P網(wǎng)絡(luò)都有其優(yōu)缺點，下表從可擴(kuò)展性、可靠性、可維護(hù)性、發(fā)現(xiàn)算法的效率、復(fù)雜查詢等方面比較了這四種拓?fù)浣Y(jié)構(gòu)的綜合性能。

　　本文以作者對JVM的理解和自己的經(jīng)驗，對Java的初始化做一個比深入的說明，由于作者有水平限制，以及JDK各實現(xiàn)版本的變化，可能仍然有不少錯誤和缺點。歡迎行家高手賜教。

　　要深入了解Java初始化，我們無法知道從程序流程上知道JVM是按什么順序來執(zhí)行的。了解JVM的執(zhí)行機(jī)制和堆棧跟蹤是有效的手段。可惜的是，到目前為止。JDK1。4和JDK1。5在javap功能上卻仍然存在著BUG。所以有些過程我無法用實際的結(jié)果向你證明兩種相反的情況。

　　<<Thinking in java>>(第三版)在第四章一開始的時候,這樣來描述Java的初始化工作:

　　以下譯文原文:

　　可以這樣認(rèn)為,每個類都有一個名為Initialize()的方法,這個名字就暗示了它得在使用之前調(diào)用,不幸的是,這么做的話,用戶就得記住要調(diào)用這個方法,java類庫的設(shè)計者們可以通過一種被稱為構(gòu)造函數(shù)的特殊方法,來保證每個對象都能得到被始化.如果類有構(gòu)造函數(shù),那么java就會在對象剛剛創(chuàng)建,用戶還來不及得到的時候,自動調(diào)用那個構(gòu)造函數(shù),這樣初始化就有保障了。

　　我不知道原作者的描述和譯者的理解之間有多大的差異,結(jié)合全章,我沒有發(fā)現(xiàn)兩個最關(guān)鍵的字"<clinit>"和"<init>"。至少說明原作者和譯者并沒有真正說明JVM在初始化時做了什么,或者說并不了解JVM的初始化內(nèi)幕,要不然明明有這兩個方法,卻為什么要認(rèn)為有一個事實上并不存在的"Initialize()"方法呢?

　　"<clinit>"和"<init>"方法在哪里？這兩個方法是實際存在而你又找不到的方法，也許正是這樣才使得一些大師都犯暈。加上jdk實現(xiàn)上的一些BUG，如果沒有深入了解，真的讓人摸不著北。

　　現(xiàn)在科學(xué)體系有一個奇怪的現(xiàn)象，那么龐大的體系最初都是建立在一個假設(shè)的基礎(chǔ)是，假設(shè)1是正確的，由此推導(dǎo)出2，再繼續(xù)推導(dǎo)出10000000000。可惜的是太多的人根本不在乎2-100000000000這樣的體系都是建立在假設(shè)1是正確的基礎(chǔ)上的。我并不會用“可以這樣認(rèn)為”這樣的假設(shè)，我要確實證明"<clinit>"和"<init>"方法是真真實實的存在的：

 package debug;
 public class MyTest{
  static int i = 100/0;
  public static void main(String[] args){
   Ssytem.out.println("Hello,World!");
  }
 }

　　執(zhí)行一下看看,這是jdk1.5的輸出：

java.lang.ExceptionInInitializerError
Caused by: java.lang.ArithmeticException: / by zero
 at debug.MyTest.(Test.java:3)
Exception in thread "main" 

　　請注意，和其它方法調(diào)用時產(chǎn)生的異常一樣，異常被定位于debug.MyTest的<clinit>.

　　再來看：

package debug;
public class Test {
  Test(){
      int i = 100 / 0;
  }
  public static void main(String[] args) {
    new Test();
  }
}
jdk1.5輸入：
 Exception in thread "main" java.lang.ArithmeticException: / by zero
  at debug.Test.<init>(Test.java:4)
  at debug.Test.main(Test.java:7)

JVM并沒有把異常定位在Test()構(gòu)造方法中，而是在debug.Test.<init>。
　　當(dāng)我們看到了這兩個方法以后，我們再來詳細(xì)討論這兩個“內(nèi)置初始化方法”（我并不喜歡生造一些
　　非標(biāo)準(zhǔn)的術(shù)語，但我確實不知道如何規(guī)范地稱呼他們）。
　　內(nèi)置初始化方法是JVM在內(nèi)部專門用于初始化的特有方法，而不是提供給程序員調(diào)用的方法，事實上“<>”這樣的語法在源程序中你連編譯都無法通過。這就說明，初始化是由JVM控制而不是讓程序員來控制的。
類初始化方法：<clinit>
　　我沒有從任何地方了解到<clinit>的cl是不是class的簡寫，但這個方法確實是用來對“類”進(jìn)行初
　　始化的。換句話說它是用來初始化static上下文的。
　　在類裝載（load）時，JVM會調(diào)用內(nèi)置的<clinit>方法對類成員和靜態(tài)初始化塊進(jìn)行初始化調(diào)用。它們的順序按照源文件的原文順序。
　　我們稍微增加兩行static語句：
package debug;
public class Test {
  static int x = 0;
  static String s = "123";
  static {
    String s1 = "456";
    if(1==1)
    throw new RuntimeException();
  }
  public static void main(String[] args) {
    new Test();
  }
}
　　然后進(jìn)行反編譯：
javap -c debug.Test
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
static int x;
static java.lang.String s;
public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."":()V
   4:   return
public static void main(java.lang.String[]);
  Code:
   0:   new     #2; //class debug/Test
   3:   dup
   4:   invokespecial   #3; //Method "":()V
   7:   pop
   8:   return
static {};
  Code:
   0:   iconst_0
   1:   putstatic       #4; //Field x:I
   4:   ldc     #5; //String 123
   6:   putstatic       #6; //Field s:Ljava/lang/String;
   9:   ldc     #7; //String 456
   11:  astore_0
   12:  new     #8; //class java/lang/RuntimeException
   15:  dup
   16:  invokespecial   #9; //Method java/lang/RuntimeException."":()V
   19:  athrow
我們可以看到,類初始化正是按照源文件中定義的原文順序進(jìn)行。先是聲明
  static  int x;
  static  java.lang.String s;
　　然后對int x和String s進(jìn)行賦值：
   0:   iconst_0
   1:   putstatic       #4; //Field x:I
   4:   ldc     #5; //String 123
   6:   putstatic       #6; //Field s:Ljava/lang/String;
　　執(zhí)行初始化塊的String s1 = "456";生成一個RuntimeException拋
   9:   ldc     #7; //String 456
   11:  astore_0
   12:  new     #8; //class java/lang/RuntimeException
   15:  dup
   16:  invokespecial   #9; //Method java/lang/RuntimeException."":()V
   19:  athrow
　　要明白的是，"<clinit>"方法不僅是類初始化方法，而且也是接口初始化方法。并不是所以接口
　　的屬性都是內(nèi)聯(lián)的，只有直接賦常量值的接口常量才會內(nèi)聯(lián)。而
　　[public static final] double d = Math.random()*100;
　　這樣的表達(dá)式是需要計算的，在接口中就要由"<clinit>"方法來初始化。
下面我們再來看看實例初始化方法"<init>"
　　"<init>"用于對象創(chuàng)建時對對象進(jìn)行初始化，當(dāng)在HEAP中創(chuàng)建對象時，一旦在HEAP分配了空間。最先就會調(diào)用"<init>"方法。這個方法包括實例變量的賦值（聲明不在其中）和初始化塊，以及構(gòu)造方法調(diào)用。如果有多個重載的構(gòu)造方法，每個構(gòu)造方法都會有一個對應(yīng)的"<init>"方法。構(gòu)造方法隱式或顯示調(diào)用父類的構(gòu)造方法前,總是先執(zhí)行實例變量初始化和初始化塊.同樣，實例變量和初始化塊的順序也是按源文件的原文順序執(zhí)行，構(gòu)造方法中的代碼在最后執(zhí)行：

package debug;
public class Test {
  int x = 0;
  String s = "123";
  {
    String s1 = "456";
    //if(1==1)
    //throw new RuntimeException();
  }
  public Test(){
    String ss = "789";
  }
  public static void main(String[] args) {
    new Test();
  }
}
javap -c debug.Test的結(jié)果：
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
int x;
java.lang.String s;
public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."":()V
   4:   aload_0
   5:   iconst_0
   6:   putfield        #2; //Field x:I
   9:   aload_0
   10:  ldc     #3; //String 123
   12:  putfield        #4; //Field s:Ljava/lang/String;
   15:  ldc     #5; //String 456
   17:  astore_1
   18:  ldc     #6; //String 789
   20:  astore_1
   21:  return
public static void main(java.lang.String[]);
  Code:
   0:   new     #7; //class debug/Test
   3:   dup
   4:   invokespecial   #8; //Method "":()V
   7:   pop
   8:   return
}
　　如果在同一個類中，一個構(gòu)造方法調(diào)用了另一個構(gòu)造方法，那么對應(yīng)的"<init>"方法就會調(diào)用另一
　　個"<init>"，但是實例變量和初始化塊會被忽略，否則它們就會被多次執(zhí)行。
package debug;
public class Test {
  String s1 = rt("s1");
  String s2 = "s2";
  
  public Test(){
    s1 = "s1";
  }
  public Test(String s){
    this();
    if(1==1) throw new Runtime();
  }
  String rt(String s){
    return s;
  }
  public static void main(String[] args) {
    new Test("");
  }
}
　　反編譯的結(jié)果：
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
java.lang.String s1;
java.lang.String s2;
public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."":()V
   4:   aload_0
   5:   aload_0
   6:   ldc     #2; //String s1
   8:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
   11:  putfield        #4; //Field s1:Ljava/lang/String;
   14:  aload_0
   15:  ldc     #5; //String s2
   17:  putfield        #6; //Field s2:Ljava/lang/String;
   20:  aload_0
   21:  ldc     #2; //String s1
   23:  putfield        #4; //Field s1:Ljava/lang/String;
   26:  return
public debug.Test(java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #7; //Method "":()V
   4:   new     #8; //class java/lang/RuntimeException
   7:   dup
   8:   invokespecial   #9; //Method java/lang/RuntimeException."":()V
   11:  athrow
java.lang.String rt(java.lang.String);
  Code:
   0:   aload_1
   1:   areturn
public static void main(java.lang.String[]);
  Code:
   0:   new     #10; //class debug/Test
   3:   dup
   4:   ldc     #11; //String
   6:   invokespecial   #12; //Method "":(Ljava/lang/String;)V
   9:   pop
   10:  return
}
　　我們看到，由于Test(String s)調(diào)用了Test();所以"<init>":(Ljava/lang/String;)V不再對
　　實例變量和初始化塊進(jìn)次初始化：
public debug.Test(java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #7; //Method "":()V
   4:   new     #8; //class java/lang/RuntimeException
   7:   dup
   8:   invokespecial   #9; //Method java/lang/RuntimeException."":()V
   11:  athrow
　　而如果兩個構(gòu)造方法是相互獨立的，則每個構(gòu)造方法調(diào)用前都會執(zhí)行實例變量和初始化塊的調(diào)用：
package debug;
public class Test {
  String s1 = rt("s1");
  String s2 = "s2";
  {
    String s3 = "s3";
  }
  public Test() {
    s1 = "s1";
  }
  public Test(String s) {
    if (1 == 1) 
      throw new RuntimeException();
  }
  String rt(String s) {
    return s;
  }
  public static void main(String[] args) {
    new Test("");
  }
}
　　反編譯的結(jié)果：
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
java.lang.String s1;
java.lang.String s2;
public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."":()V
   4:   aload_0
   5:   aload_0
   6:   ldc     #2; //String s1
   8:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
   11:  putfield        #4; //Field s1:Ljava/lang/String;
   14:  aload_0
   15:  ldc     #5; //String s2
   17:  putfield        #6; //Field s2:Ljava/lang/String;
   20:  ldc     #7; //String s3
   22:  astore_1
   23:  aload_0
   24:  ldc     #2; //String s1
   26:  putfield        #4; //Field s1:Ljava/lang/String;
   29:  return
public debug.Test(java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."":()V
   4:   aload_0
   5:   aload_0
   6:   ldc     #2; //String s1
   8:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
   11:  putfield        #4; //Field s1:Ljava/lang/String;
   14:  aload_0
   15:  ldc     #5; //String s2
   17:  putfield        #6; //Field s2:Ljava/lang/String;
   20:  ldc     #7; //String s3
   22:  astore_2
   23:  new     #8; //class java/lang/RuntimeException
   26:  dup
   27:  invokespecial   #9; //Method java/lang/RuntimeException."":()V
   30:  athrow
java.lang.String rt(java.lang.String);
  Code:
   0:   aload_1
   1:   areturn
public static void main(java.lang.String[]);
  Code:
   0:   new     #10; //class debug/Test
   3:   dup
   4:   ldc     #11; //String
   6:   invokespecial   #12; //Method "":(Ljava/lang/String;)V
   9:   pop
   10:  return
}
　　明白了上面這些知識,我們來做一個小測試吧:
public class Test2 extends Test1{
 {
  System.out.print("1");
 }
 Test2(){
  System.out.print("2");
 }
 static{
  System.out.print("3");
 }
 {
  System.out.print("4");
 }
 public static void main(String[] args) {
  new Test2();
 }
}
class Test1 {
 Test1(){
  System.out.print("5"); 
 }
 static{
  System.out.print("6");
 }
}
　　試試看能清楚打印的順序嗎?如果沒有new Test2()將打印什么?

作者:axman  專欄:http://blog.csdn.net/axman/