久久国产精品成人免费,久久这里只有精品久久,亚洲伊人久久精品影院

2013年9月28日

淺談Java內部類

什么是內部類呢？顧名思義，內部類就是在類中可以定義另一個的類。內部類是外部對象的一個成員，同樣具有public , private 和 protected的訪問權限。

public class Test
{
    public static void main(String[] args)
    {
      Family my = new Family(“Jonh",130);
      my.getMsg();
    }
}
class Family
{
     Family(String name,int weight){ this.f = new Father(name,weight); }
     private class Father
     {
       private int weight;
       private String name;
       Father(String n,int w)
       {
          this.name = n;
          this.weight = w;
       }
       public int getWeight()
       {
          return weight;
       }
       public String getName()
       {
          return name;
       }
      }

     private Father f;
     public void getMsg()
     {
          System.out.println("Name: "+f.getName()+"\nWeight: "+f.getWeight());
     }
}

類Family 中有一個Father類，聲明為private，表明在Family類中可以創建一個實例對象，這個Father專屬于Family類。普通的（非內部）類不能聲明為private或者protected，只能聲明為public。因此這樣的代碼是不被允許的：

Family.Father a = my.new Father("Jonh",150);

如果要使用上述代碼，只要修改內部類的訪問權限就可以了，如去掉private權限，則默認為包訪問權限，同一個包中的類都可以訪問它，而不是只能從Family類才能訪問。

public class test
{
    public static void main(String[] args)
    {
      Family my = new Family("Jonh",130);
      my.getMsg();
      Family.Father a = my.new Father("Jonh",150);
      System.out.println("Name: "+a.getName()+"\nWeight: "+a.getWeight());

    }
}

在上述代碼中，在創建內部類對象時，語法為：Family.Father a = my.new Father("Jonh",150); 說明內部類對象的創建是基于一個外部類對象（my），也就是說內部類對象必須依附于一個外部類對象。

內部類可以出現在所屬類的方法內或任意作用域內。像下面的代碼將內部類嵌入在方法內：

public class test
{
    public static void main(String[] args)
    {
      Family my = new Family();
      my.getMsg("Jonh",150);

    }
}
class Family
{
     Family(){ }
     public void getMsg(String s,int n)
     {
       class Father
      {
       private int weight;
       private String name;
       Father(String n,int w)
       {
          this.name = n;
          this.weight = w;
       }
       public int getWeight()
       {
          return weight;
       }
       public String getName()
       {
          return name;
       }
      }
      Father f = new Father(s,n);
      System.out.println("Name: "+f.getName()+"\nWeight: "+f.getWeight());
     }
}

閉包

內部類可以訪問外部類的成員變量（即使是private），如在Family類中添加成員變量height，在Father類中定義一個方法 getHeight()，則能成功訪問這個height變量，而在外部類中不能訪問內部類中的成員變量。

class Family
{
     private int height = 180; /*定義外部類屬性height*/
     Family(String name,int weight){ this.f = new Father(name,weight); }
     private class Father
     {
       private int weight;
       private String name;
       Father(String n,int w)
       {
          this.name = n;
          this.weight = w;
       }
       public int getWeight()
       {
          return weight;
       }
       public String getName()
       {
          return name;
       }
       public int getHeight()
       {
          return height;   /*訪問外部類的屬性height*/
       }
      }

     private Father f;
     public void getMsg()
     {
          System.out.println("Name: "+f.getName()+"\nWeight: "+f.getWeight()+"\nHeight: "+f.getHeight());
     }
}
public class test
{
    public static void main(String[] args)
    {
      Family my = new Family("Jonh",130);
      my.getMsg();
  /* not allowed */

/* System.out.println(my.weight); */

}
}

如果把內部類單獨拿到外面來聲明，那么要使用外部類的屬性如height，就要先創建外部類的對象，再由對象調用其height屬性，現在由于內部類處于外部類中，所以在程序調用時不必再創建外部類的對象，直接就可以使用height，這樣減少了一部分內存空間的開銷。

嵌套static類

在類內部定義static類，稱為嵌套static類。
我們可以直接創建嵌套類，而不必依賴于某個外部類對象。嵌套類無法調用外部對象的方法、也無法讀取或修改外部對象的數據。
如：

public class Test{
    public static void main(String[] args){
        Father.Son John = new Father.Son();
        John.display();
     }
}

class Father{
  /*嵌套類*/
static class Son{
     public void display(){
        System.out.println("I am his son.");
     }
   }
}

總結
1. 內部類豐富了類的組織形式；
2. 內部類實現了閉包。

posted @ 2013-09-28 14:26 hoshelly 閱讀(255) | 評論 (0) | 編輯收藏

2013年9月27日

棧和堆（轉）

摘抄自：http://www.cnblogs.com/vamei

當程序文件運行為進程的時候，進程在內存中得到空間(進程自己的小房間)。每個進程空間按照如下方式分為不同區域:

內存空間

Text區域用來儲存指令(instruction)，來告訴程序每一步的操作。Global Data用于存放全局變量，stack用于存放局部變量，heap用于存放動態變量 (dynamic variable. 程序利用malloc系統調用，直接從內存中為dynamic variable開辟空間)。Text和Global data在進程一開始的時候就確定了，并在整個進程中保持固定大小。

Stack(棧)以stack frame為單位。當程序調用函數的時候，比如main()函數中調用inner()函數，stack會向下增長一個stack frame。Stack frame中存儲該函數的參數和局部變量，以及該函數的返回地址(return address)。此時，計算機將控制權從main()轉移到inner()，inner()函數處于激活(active)狀態。位于Stack最下方的frame和Global Data就構成了當前的環境(context)。激活函數可以從中調用需要的變量。典型的編程語言都只允許你使用位于stack最下方的frame ，而不允許你調用其它的frame (這也符合stack結構“先進后出”的特征。但也有一些語言允許你調用stack的其它部分，相當于允許你在運行inner()函數的時候調用main()中聲明的局部變量，比如Pascal)。當函數又進一步調用另一個函數的時候，一個新的frame會繼續增加到stack下方，控制權轉移到新的函數中。當激活函數返回的時候，會從stack中彈出(pop，就是讀取并刪除)該frame，并根據frame中記錄的返回地址，將控制權交給返回地址所指向的指令(比如從inner()函數中返回，繼續執行main()中賦值給main2的操作)。

下圖是stack在運行過程中的變化，箭頭表示stack增長的方向，每個方塊代表一個stack frame。開始的時候我們有一個為main()服務的frame，隨著調用inner()，我們為inner()增加一個frame。在inner()返回時，我們再次只有main()的frame，直到最后main()返回，其返回地址為空，所以進程結束。

stack變化

在進程運行的過程中，通過調用和返回函數，控制權不斷在函數間轉移。進程可以在調用函數的時候，原函數的stack frame中保存有在我們離開時的狀態，并為新的函數開辟所需的stack frame空間。在調用函數返回時，該函數的stack frame所占據的空間隨著stack frame的彈出而清空。進程再次回到原函數的stack frame中保存的狀態，并根據返回地址所指向的指令繼續執行。上面過程不斷繼續，stack不斷增長或減小，直到main()返回的時候，stack完全清空，進程結束。

當程序中使用malloc的時候，heap(堆)會向上增長，其增長的部分就成為malloc從內存中分配的空間。malloc開辟的空間會一直存在，直到我們用free系統調用來釋放，或者進程結束。一個經典的錯誤是內存泄漏(memory leakage), 就是指我們沒有釋放不再使用的heap空間，導致heap不斷增長，而內存可用空間不斷減少。

由于stack和heap的大小則會隨著進程的運行增大或者變小，當stack和heap增長到兩者相遇時候，也就是內存空間圖中的藍色區域(unused area)完全消失的時候，進程會出現棧溢出(stack overflow)的錯誤，導致進程終止。在現代計算機中，內核一般都會為進程分配足夠多的藍色區域，如果我們即時清理的話，stack overflow是可以避免的。但是，在進行一些矩陣運算的時候，由于所需的內存很大，依然可能出現stack overflow的情況。一種解決方式是增大內核分配給每個進程的內存空間。如果依然不能解決問題的話，我們就需要增加物理內存。

堆和棧的區別：

2.1申請方式
stack:
由系統自動分配。   例如，聲明在函數中一個局部變量   int   b;   系統自動在棧中為b開辟空
間
heap:
需要程序員自己申請，并指明大小，在c中malloc函數
如p1   =   (char   *)malloc(10);
在C++中用new運算符
如p2   =   new   char[10];
但是注意p1、p2本身是在棧中的。


2.2
申請后系統的響應
棧：只要棧的剩余空間大于所申請空間，系統將為程序提供內存，否則將報異常提示棧溢
出。
堆：首先應該知道操作系統有一個記錄空閑內存地址的鏈表，當系統收到程序的申請時，
會遍歷該鏈表，尋找第一個空間大于所申請空間的堆結點，然后將該結點從空閑結點鏈表
中刪除，并將該結點的空間分配給程序，另外，對于大多數系統，會在這塊內存空間中的
首地址處記錄本次分配的大小，這樣，代碼中的delete語句才能正確的釋放本內存空間。
另外，由于找到的堆結點的大小不一定正好等于申請的大小，系統會自動的將多余的那部
分重新放入空閑鏈表中。

2.3申請大小的限制
棧：在Windows下,棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意
思是棧頂的地址和棧的最大容量是系統預先規定好的，在WINDOWS下，棧的大小是2M（也有
的說是1M，總之是一個編譯時就確定的常數），如果申請的空間超過棧的剩余空間時，將
提示overflow。因此，能從棧獲得的空間較小。
堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是由于系統是用鏈表來存儲
的空閑內存地址的，自然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小
受限于計算機系統中有效的虛擬內存。由此可見，堆獲得的空間比較靈活，也比較大。



2.4申請效率的比較：
棧由系統自動分配，速度較快。但程序員是無法控制的。
堆是由new分配的內存，一般速度比較慢，而且容易產生內存碎片,不過用起來最方便.
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配內存，他不是在堆，也不是在棧是
直接在進程的地址空間中保留一塊內存，雖然用起來最不方便。但是速度快，也最靈活。


2.5堆和棧中的存儲內容
棧：   在函數調用時，第一個進棧的是主函數中后的下一條指令（函數調用語句的下一條可
執行語句）的地址，然后是函數的各個參數，在大多數的C編譯器中，參數是由右往左入棧
的，然后是函數中的局部變量。注意靜態變量是不入棧的。
當本次函數調用結束后，局部變量先出棧，然后是參數，最后棧頂指針指向最開始存的地
址，也就是主函數中的下一條指令，程序由該點繼續運行。
堆：一般是在堆的頭部用一個字節存放堆的大小。堆中的具體內容由程序員安排。

2.6存取效率的比較

char   s1[]   =   "aaaaaaaaaaaaaaa";
char   *s2   =   "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在運行時刻賦值的；
而bbbbbbbbbbb是在編譯時就確定的；
但是，在以后的存取中，在棧上的數組比指針所指向的字符串(例如堆)快。

2.7小結：
堆和棧的區別可以用如下的比喻來看出：
使用棧就象我們去飯館里吃飯，只管點菜（發出申請）、付錢、和吃（使用），吃飽了就
走，不必理會切菜、洗菜等準備工作和洗碗、刷鍋等掃尾工作，他的好處是快捷，但是自
由度小。
使用堆就象是自己動手做喜歡吃的菜肴，比較麻煩，但是比較符合自己的口味，而且自由
度大。   (經典！)

posted @ 2013-09-27 09:13 hoshelly 閱讀(298) | 評論 (0) | 編輯收藏

Java對象引用（轉）

作者：Vamei 出處：http://www.cnblogs.com/vamei 歡迎轉載，也請保留這段聲明。謝謝！

我們之前一直在使用“對象”這個概念，但沒有探討對象在內存中的具體存儲方式。這方面的討論將引出“對象引用”(object reference)這一重要概念。

對象引用

我們沿用之前定義的Human類，并有一個Test類:

復制代碼

public class Test

{

public static void main(String[] args)

{

Human aPerson = new Human(160);

}

class Human

{

/**

* constructor

public Human(int h)

{

this.height = h;

}

/**

* accessor

public int getHeight()

{

return this.height;

}

/**

* mutator

public void growHeight(int h)

{

this.height = this.height + h;

}

private int height;

}

復制代碼

外部可以調用類來創建對象，比如上面在Test類中:

Human aPerson = new Human(160);

創建了一個Human類的對象aPerson。

上面是一個非常簡單的表述，但我們有許多細節需要深入:

首先看等號的右側。new是在內存中為對象開辟空間。具體來說，new是在內存的堆(heap)上為對象開辟空間。這一空間中，保存有對象的數據和方法。

再看等號的左側。aPerson指代一個Human對象，被稱為對象引用(reference)。實際上，aPerson并不是對象本身，而是類似于一個指向對象的指針。aPerson存在于內存的棧(stack)中。

當我們用等號賦值時，是將右側new在堆中創建對象的地址賦予給對象引用。

這里的內存，指的是JVM (Java Virtual Machine)虛擬出來的Java進程內存空間。內存的堆和棧概念可參考Linux從程序到進程。

對象引用

棧的讀取速度比堆快，但棧上存儲的數據受到有效范圍的限制。在C語言中，當一次函數調用結束時，相應的棧幀(stack frame)要刪除，棧幀上存儲的參量和自動變量就消失了。Java的棧也受到同樣的限制，當一次方法調用結束，該方法存儲在棧上的數據將清空。在 Java中，所有的(普通)對象都儲存在堆上。因此，new關鍵字的完整含義是，在堆上創建對象。

基本類型(primitive type)的對象，比如int, double，保存在棧上。當我們聲明基本類型時，不需要new。一旦聲明，Java將在棧上直接存儲基本類型的數據。所以，基本類型的變量名表示的是數據本身，不是引用。

引用和對象的關系就像風箏和人。我們看天空時(程序里寫的)，看到的是風箏(引用)，但風箏下面對應的，是人(對象):

引用和對象分離；引用指向對象

盡管引用和對象是分離的，但我們所有通往對象的訪問必須經過引用這個“大門”，比如以引用.方法() 的方式訪問對象的方法。在Java中，我們不能跳過引用去直接接觸對象。再比如，對象a的數據成員如果是一個普通對象b，a的數據成員保存的是指向對象b的引用 (如果是基本類型變量，那么a的數據成員保存的是基本類型變量本身了)。

在Java中，引用起到了指針的作用，但我們不能直接修改指針的值，比如像C語言那樣將指針值加1。我們只能通過引用執行對對象的操作。這樣的設計避免了許多指針可能引起的錯誤。

引用的賦值

當我們將一個引用賦值給另一個引用時，我們實際上復制的是對象的地址。兩個引用將指向同一對象。比如 dummyPerson=aPerson;，將導致:

一個對象可以有多個引用 (一個人可以放多個風箏)。當程序通過某個引用修改對象時，通過其他引用也可以看到該修改。我們可以用以下Test類來測試實際效果:

復制代碼

public class Test

{

public static void main(String[] args)

{

Human aPerson = new Human(160);

Human dummyPerson = aPerson;

System.out.println(dummyPerson.getHeight());

aPerson.growHeight(20);

System.out.println(dummyPerson.getHeight());

}

復制代碼

我們對aPerson的修改將影響到dummyPerson。這兩個引用實際上指向同一對象。

所以，將一個引用賦值給另一個引用，并不能復制對象本身。我們必須尋求其他的機制來復制對象。

垃圾回收

隨著方法調用的結束，引用和基本類型變量會被清空。由于對象存活于堆，所以對象所占據的內存不會隨著方法調用的結束而清空。進程空間可能很快被不斷創建的對象占滿。Java內建有垃圾回收(garbage collection)機制，用于清空不再使用的對象，以回收內存空間。

垃圾回收的基本原則是，當存在引用指向某個對象時，那么該對象不會被回收; 當沒有任何引用指向某個對象時，該對象被清空。它所占據的空間被回收。

上圖假設了某個時刻JVM中的內存狀態。Human Object有三個引用: 來自棧的aPerson和dummyPerson，以及另一個對象的數據成員president。而Club Object沒有引用。如果這個時候垃圾回收啟動，那么Club Object將被清空，而Human Object來自Club Object的引用(president)也隨之被刪除。

垃圾回收是Java中重要的機制，它直接影響了Java的運行效率。我將在以后深入其細節。

參數傳遞

當我們分離了引用和對象的概念后，Java方法的參數傳遞機制實際上非常清晰: Java的參數傳遞為值傳遞。也就是說，當我們傳遞一個參數時，方法將獲得該參數的一個拷貝。

實際上，我們傳遞的參數，一個是基本類型的變量，另一個為對象的引用。

基本類型變量的值傳遞，意味著變量本身被復制，并傳遞給Java方法。Java方法對變量的修改不會影響到原變量。

引用的值傳遞，意味著對象的地址被復制，并傳遞給Java方法。Java方法根據該引用的訪問將會影響對象。

在這里有另一個值得一提的情況: 我們在方法內部使用new創建對象，并將該對象的引用返回。如果該返回被一個引用接收，由于對象的引用不為0，對象依然存在，不會被垃圾回收。

總結

new

引用，對象

被垃圾回收的條件

參數: 值傳遞

posted @ 2013-09-27 08:39 hoshelly 閱讀(567) | 評論 (0) | 編輯收藏

2013年7月5日

Java socket編程入門（轉）

這個網站上講得很清楚，就不轉載了，直接貼地址：http://www.binarytides.com/java-socket-programming-tutorial/

posted @ 2013-07-05 15:55 hoshelly 閱讀(223) | 評論 (0) | 編輯收藏

2013年5月14日

exec函數

用f o r k函數創建子進程后，子進程往往要調用一種e x e c函數以執行另一個程序。當進程調用一種e x e c函數時，該進程完全由新程序代換，而新程序則從其 m a i n函數開始執行。因為調用e x e c并不創建新進程，所以前后的進程I D并未改變。e x e c只是用另一個新程序替換了當前進程的正文、數據、堆和棧段。

有六種不同的e x e c函數可供使用（具體參考APUE），它們常常被統稱為e x e c函數。這些e x e c函數都是U N I X進程控制原語。用f o r k可以創建新進程，用e x e c可以執行新的程序。e x i t函數和兩個w a i t函數處理終止和等待終止。這些是我們需要的基本的進程控制原語。

posted @ 2013-05-14 17:37 hoshelly 閱讀(871) | 評論 (0) | 編輯收藏

init進程與僵尸進程

在說明f o r k函數時，一定是一個父進程生成一個子進程。上面又說明了子進程將其終止狀態返回給父進程。但是如果父進程在子進程之前終止，則將如何呢？其回答是對于其父進程已經終止的所有進程，它們的父進程都改變為i n i t進程。

我們稱這些進程由i n i t進程領養。其操作過程大致是：在一個進程終止時，內核逐個檢查所有活動進程，以判斷它是否是正要終止的進程的子進程，如果是，則該進程的父進程I D就更改為1 ( i n i t進程的I D )。這種處理方法保證了每個進程有一個父進程。

如果子進程在父進程之前終止，那么父進程又如何能在做相應檢查時得到子進程的終止狀態呢？對此問題的回答是內核為每個終止子進程保存了一定量的信

息，所以當終止進程的父進程調用 w a i t或waitpid 時，可以得到有關信息。這種信息至少包括進程I D、該進程的終止狀態、以反該進程使用的 C P U時間總量。內核可以釋放終止進程所使用的所有存儲器，關閉其所有打開文件。在 U N I X術語中，一個已經終止、但是其父進程尚未對其進行善后處理（獲取終止子進程的有關信息、釋放它仍占用的資源）的進程被稱為僵死進程（z o m b i e）。p s ( 1 )命令將僵死進程的狀態打印為 Z。

一個由i n i t進程領養的進程終止時會發生什么?它會不會變成一個僵死進程？對此問題的回答是“否”，因為i n i t被編寫成只要有一個子進程終止， i n i t就會調用一個w a i t函數取得其終止狀態。這樣也就防止了在系統中有很多僵死進程。當提及“一個i n i t的子進程”時，這指的是i n i t直接產生的進程，或者是其父進程已終止，由init 領養的進程。

posted @ 2013-05-14 17:32 hoshelly 閱讀(483) | 評論 (0) | 編輯收藏

fork 和 vfork 的區別 & exit 和_exit的區別

1.1
fork可以創建一個新的子進程，調用一次，返回兩次，一次返回0值給子進程，另一次返回新的子進程的ID給父進程。子進程是父進程的復制品，擁有父進程的數據空間、堆和棧，父子進程并不共享存儲空間，如果正文段是只讀的，那么父子進程共享正文段。
一般而言，fork之后是父進程先執行還是子進程先執行是不確定的，這取決于內核的調度算法。
fork有兩種用法：
（1）一個父進程希望復制自己，使父、子進程同時執行不同的代碼段。這在網絡服務進程中是常見的——父進程等待委托者的服務請求。當這種請求到達時，父進程調用 f o r k，使子進程處理此請求。父進程則繼續等待下一個服務請求。

（2）一個進程要執行一個不同的程序。這對s h e l l是常見的情況。在這種情況下，子進程在從f o r k返回后立即調用e x e c。

1.2
vfork用于創建一個新的進程，而新的進程的目的就是exec一個新程序，vfork并不將父進程的地址空間復制給子進程，因為子進程會立即調用exec（_exit），于是也就不會訪問地址空間。不過它在調用exec或_exit之前，它在父進程的空間中運行。

fork創建的子進程共享父進程的數據段、堆棧段；vfork創建的子進程共享父進程的數據段。

vfork與fork的另一個區別是：vfork保證子進程先運行，在它調用exec或exit之后父進程才可能被調度運行，（如果在調用這兩個函數之前子進程依賴于父進程的進一步動作，則會導致死鎖）。

2.1
exit和_exit都是正常終止進程，_exit用于vfork時父進程有可能會被調度，它們都不同于異常終止abort，在異常終止情況下，內核（不是進程）產生一個指示其終止異常終止原因的終止狀態。

posted @ 2013-05-14 17:26 hoshelly 閱讀(327) | 評論 (0) | 編輯收藏

ourhdr.h編譯錯誤時解決辦法

網上找的，摘抄如下：

＃include "apue.h"

這個頭文件是作者把每個例程中常用的標準頭文件，一些常用的出錯處理函數（err_**（）之類的函

數）和一些常用的宏定義給整理在一個頭文件中。這個可以省去在每個例程中錄入較多的重復代碼，這樣可

以減少每個例程的長度。但給讀者帶來了不少麻煩。下面給出源代碼的編譯方法。

一：整體編譯：

1.APUE2源代碼下載：http://www.apuebook.com/src.tar.gz

2.我保存到了/home/wx下.解壓縮:tar zxvf src.tar.gz

3.cd apue.2e到apue.2e目錄（查看README,告訴我們linux系統只要修改Make.defines.linux再make）

4.vi Make.defines.linux 修改WKDIR=/home/wx/apue.2e 就是說工作目錄為WKDIR=/home/wx/apue.2e

5.修改/home/wx/apue.2e/std/linux.mk把全部的nawk改為awk.因些linux默認沒有nawk

6.cd /home/wx/apue.2e

make

7.把生成的apue.2e/lib/libapue.a與apue.2e/include/apue.h拷貝到你編寫的源代碼目錄下。

（注：你可以把libapue.a和apue.h保存在容易找到的文件夾中，以便使用）

8.使用gcc -o ls1 ls1.c libapue.a來編譯你的源代碼

9.成功

posted @ 2013-05-14 16:03 hoshelly 閱讀(297) | 評論 (0) | 編輯收藏

2013年4月13日

Vim文本的選擇

在正常模式下（按ESC進入）按鍵v進入可視化模式，然后按鍵盤左右鍵或h,l鍵即可實現文本的選擇。

其它相關命令：

v：按字符選擇。經常使用的模式，所以親自嘗試一下它。

V：按行選擇。這在你想拷貝或者移動很多行的文本的時候特別有用。

CTRL＋v：按塊選擇。非常強大，只在很少的編輯器中才有這樣的功能。你可以選擇一個矩形塊，并且在這個矩形里面的文本會被高亮。

值得注意的是如果VIM中使用自動換行，那么直到你按ENTER換行前，VIM都會將你之前輸入的內容視為一行而不是你看到的好幾行，按塊選擇時就會按VIM中的行來選擇塊。

在選擇模式的時候使用上面所述的方向鍵和命令（motion）。比如，vwww，會高亮光標前面的三個詞。Vjj 將會高亮當前行以及下面兩行。

posted @ 2013-04-13 22:57 hoshelly 閱讀(314) | 評論 (0) | 編輯收藏

wait 和waitpid詳解

wait的函數原型是：　

#include<sys/types.h>

#include <sys/wait.h>

pid_t wait(int *status) 　　　　

進程一旦調用了wait，就立即阻塞自己，由wait自動分析是

否當前進程的某個子進程已經退出，如果讓它找到了這樣一個

已經變成僵尸的子進程， wait就會收集這個子進程的信息，并

把它徹底銷毀后返回；如果沒有找到這樣一個子進程，wait就

會一直阻塞在這里，直到有一個出現為止。　　　　

參數status用來保存被收集進程退出時的一些狀態，它是

一個指向int類型的指針。但如果我們對這個子進程是如何死掉

的毫不在意，只想把這個僵尸進程消滅掉，（事實上絕大多數

情況下，我們都會這樣想），我們就可以設定這個參數為

NULL，就象下面這樣：　　　　pid = wait(NULL);

如果成功，wait會返回被收集的子進程的進程ID，如果調用進

程沒有子進程，調用就會失敗，此時wait返回-1，同時errno被

置為ECHILD。　

waitpid的函數原型是：　　

waitpid系統調用在Linux函數庫中的原型是：　　

#include <sys/types.h>#include <sys/wait.h>

pid_t waitpid(pid_t pid,int *status,int options)

從本質上講，系統調用waitpid和wait的作用是完全相同

的，但waitpid多出了兩個可由用戶控制的參數pid和options，

從而為我們編程提供了另一種更靈活的方式。

下面我們就來詳細介紹一下這兩個參數：　　　　

● pid 　　　　從參數的名字pid和類型pid_t中就可以看出，

這里需要的是一個進程ID。但當pid取不同的值時，在這里有不

同的意義。　　　　pid>0時，只等待進程ID等于pid的子進

程，不管其它已經有多少子進程運行結束退出了，只要指定的

子進程還沒有結束，waitpid就會一直等下去。　　　　pid=-

1時，等待任何一個子進程退出，沒有任何限制，此時waitpid

和wait的作用一模一樣。　　　　pid=0時，等待同一個進程

組中的任何子進程，如果子進程已經加入了別的進程組，

waitpid不會對它做任何理睬。　　　　pid<-1時，等待一個

指定進程組中的任何子進程，這個進程組的ID等于pid的絕對

值。　　

● options 　　options提供了一些額外的選項來控制waitpid，

目前在Linux中只支持WNOHANG和WUNTRACED兩個選項，

這是兩個常數，可以用"|"運算符把它們連接起來使用，比如：

　　ret=waitpid(-1,NULL,WNOHANG | WUNTRACED); 　　

如果我們不想使用它們，也可以把options設為0，如：　　

ret=waitpid(-1,NULL,0); 　　　　如果使用了WNOHANG參數

調用waitpid，即使沒有子進程退出，它也會立即返回，不會像

wait那樣永遠等下去。　　　　而WUNTRACED參數，由于

涉及到一些跟蹤調試方面的知識，加之極少用到，這里就不多

費筆墨了，有興趣的讀者可以自行查閱相關材料。　　　　看

到這里，聰明的讀者可能已經看出端倪了--wait不就是經過包裝

的waitpid嗎？沒錯，察看<內核源碼目錄>/include/unistd.h文

件349-352行就會發現以下程序段：　　　　static inline

pid_t wait(int * wait_stat) 　　{ 　　 return waitpid(-

1,wait_stat,0); 　　} 　　　　返回值和錯誤　　　　

waitpid的返回值比wait稍微復雜一些，一共有3種情況：　

● 當正常返回的時候，waitpid返回收集到的子進程的進程ID；

● 如果設置了選項WNOHANG，而調用中waitpid發現沒有已

退出的子進程可收集，則返回0；　　　　

● 如果調用中出錯，則返回-1，這時errno會被設置成相應的

值以指示錯誤所在；當pid所指示的子進程不存在，或此進程存

在，但不是調用進程的子進程，waitpid就會出錯返回，這時

errno被設置為ECHILD 其它：調用 wait＆waitpid 來處理終止

的子進程： pid_t wait(int * statloc); pid_t waitpid(pid_t pid,

int *statloc, int options); 兩個函數都返回兩個值：函數的返回

值和終止的子進程ID，而子進程終止的狀態則是通過statloc指

針返回的。 wait＆waitpid 的區別是顯而易見的，wait等待第一

個終止的子進程，而waitpid則可以指定等待特定的子進程。這

樣的區別可能會在下面這種情況時表現得更加明顯：當同時有

5個客戶連上服務器，也就是說有五個子進程分別對應了5個客

戶，此時，五個客戶幾乎在同時請求終止，這樣一來，幾乎同

時，五個FIN發向服務器，同樣的，五個SIGCHLD信號到達服

務器，然而，UNIX的信號往往是不會排隊的，顯然這樣一來，

信號處理函數將只會執行一次，殘留剩余四個子進程作為僵尸

進程駐留在內核空間。此時，正確的解決辦法是利用waitpid(-

1, &stat, WNOHANG)防止留下僵尸進程。其中的pid為－1表

明等待第一個終止的子進程，而WNOHANG選擇項通知內核在

沒有已終止進程項時不要阻塞。

wait＆waitpid 區別 :

waitpid提供了wait函數不能實現的3個功能: waitpid等待特定的

子進程, 而wait則返回任一終止狀態的子進程; waitpid提供了一

個wait的非阻塞版本; waitpid支持作業控制(以WUNTRACED選

項). 用于檢查wait和waitpid兩個函數返回終止狀態的宏: 這兩個

函數返回的子進程狀態都保存在statloc指針中, 用以下3個宏可

以檢查該狀態: WIFEXITED(status): 若為正常終止, 則為真. 此

時可執行 WEXITSTATUS(status): 取子進程傳送給exit或_exit

參數的低8位. WIFSIGNALED(status): 若為異常終止, 則為真.

此時可執行 WTERMSIG(status): 取使子進程終止的信號編號.

WIFSTOPPED(status): 若為當前暫停子進程, 則為真. 此時可

執行 WSTOPSIG(status): 取使子進程暫停的信號編號

posted @ 2013-04-13 22:05 hoshelly 閱讀(1366) | 評論 (0) | 編輯收藏

僅列出標題下一頁

天之道

淺談Java內部類

棧和堆（轉）

Java對象引用（轉）

Java socket編程入門（轉）

exec函數

init進程與僵尸進程

fork 和 vfork 的區別 & exit 和_exit的區別

ourhdr.h編譯錯誤時解決辦法

Vim文本的選擇

wait 和waitpid詳解

日歷

常用鏈接

留言簿(2)

隨筆分類

隨筆檔案

搜索

最新評論

閱讀排行榜

評論排行榜