天之道

享受编程的乐趣。
posts - 118, comments - 7, trackbacks - 0, articles - 0
  C++博客 :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理

2013年9月28日


什么是内部类呢?顾名思义,内部类就是在类中可以定义另一个的类。内部类是外部对象的一个成员,同样具有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 阅读(128) | 评论 (0)编辑 收藏

2013年9月27日

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

当程序文件运行为进程的时候,进程在内存中得到空间(进程自己的小房间)。每个进程空间按照如下方式分为不同区域:

                    内存空间

Text区域用来储存指令(instruction),来告诉程序每一步的操作。Global Data用于存放全局变量,stack用于存放局部变量,heap用于存放动态变量 (dynamic variable. 程序利用malloc系统调用,直接从内存中为dynamic variable开辟空间)。TextGlobal 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 阅读(116) | 评论 (0)编辑 收藏

作者: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 阅读(292) | 评论 (0)编辑 收藏

2013年7月5日

这个网站上讲得很清楚,就不转载了,直接贴地址:http://www.binarytides.com/java-socket-programming-tutorial/

posted @ 2013-07-05 15:55 hoshelly 阅读(115) | 评论 (0)编辑 收藏

2013年5月14日

用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 阅读(364) | 评论 (0)编辑 收藏

在说明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 阅读(166) | 评论 (0)编辑 收藏

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 阅读(139) | 评论 (0)编辑 收藏

网上找的,摘抄如下:

#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 阅读(133) | 评论 (0)编辑 收藏

2013年4月13日


在正常模式下(按ESC进入)按键v进入可视化模式,然后按键盘左右键或h,l键即可实现文本的选择。
其它相关命令:
v:按字符选择。经常使用的模式,所以亲自尝试一下它。
V:按行选择。这在你想拷贝或者移动很多行的文本的时候特别有用。

CTRL+v:按块选择。非常强大,只在很少的编辑器中才有这样的功能。你可以选择一个矩形块,并且在这个矩形里面的文本会被高亮。

值得注意的是如果VIM中使用自动换行,那么直到你按ENTER换行前,VIM都会将你之前输入的内容视为一行而不是你看到的好几行,按块选择时就会按VIM中的行来选择块。

在选择模式的时候使用上面所述的方向键和命令(motion)。比如,vwww,会高亮光标前面的三个词。Vjj 将会高亮当前行以及下面两行。

posted @ 2013-04-13 22:57 hoshelly 阅读(189) | 评论 (0)编辑 收藏

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 阅读(182) | 评论 (0)编辑 收藏