天之道

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

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

栈和堆（转）

摘抄自：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 阅读(280) | 评论 (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 阅读(537) | 评论 (0) | 编辑 收藏

Java socket编程入门（转）

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

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

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 阅读(852) | 评论 (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 阅读(466) | 评论 (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 阅读(313) | 评论 (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 阅读(281) | 评论 (0) | 编辑 收藏

Vim文本的选择


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

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

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

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

posted @ 2013-04-13 22:57 hoshelly 阅读(301) | 评论 (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 阅读(1324) | 评论 (0) | 编辑 收藏

仅列出标题
共12页: 1 2 3 4 5 6 7 8 9 Last