UNIX环境高级编程-第8章- 进程控制 - 二

最新推荐文章于 2020-12-26 14:36:29 发布
最新推荐文章于 2020-12-26 14:36:29 发布
阅读量506 收藏
点赞数
分类专栏： UNIX环境高级编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012243115/article/details/42081375
版权

8.10 exec函数

exec 替换进程映像

        在进程的创建上 UNIX 采用了一个独特的方法，它将进程创建与加载一个新进程映象分离，这样可以方便对两种操作进行管理。当创建了一个进程之后，通常可以用 exec 系列的函数将子进程替换成新的进程映象。当然，exec 系列的函数也可以将当前进程替换掉。

exec 序列函数

        fork 函数创建一个子进程时，几乎复制了父进程的全部内容。exec 序列函数可以在一个在进程中启动另一个程序的执行，它可以根据指定的文件名或目录名找到可执行文件，并用它来取代原调用进程的数据段、代码段和堆栈段，在执行完之后，原调用进程的内容除了进程 ID 未改变（ exec 序列函数不创建新进程），其他全部被新的程序替换了。
        在 Linux 中使用 exec 序列函数主要有两种情况：

1、当进程认为自己不能再为系统和用户做出任何贡献时，就可以调用 exec 序列函数中的任意一个函数让自己重生。

2、如果一个进程想执行另一个程序，那么它就可以调用 fork 函数新建一个进程，然后调用 exec 序列函数中的任意一个函数，这样看起来就像通过执行应用程序而产生了一个新进程（这种情况非常普遍）。

/* exec 序列函数 */  
  
/* 
 * 函数功能：把当前进程替换为一个新的进程，新进程与原进程ID相同； 
 * 返回值：若出错则返回-1，若成功则不返回； 
 * 函数原型： 
 */  
#include <unistd.h>  
int execl(const char *pathname, const char *arg, ...);  
int execv(const char *pathnam, char *const argv[]);  
int execle(const char *pathname, const char *arg, ... , char *const envp[]);  
int execve(const char *pathnam, char *const argv[], char *const envp[]);  
int execlp(const char *filename, const char *arg, ...);  
int execvp(const char *filename, char *const argv[]);

        这6个函数在函数名和使用语法的规则上都有细微的区别，下面就从可执行文件查找方式、参数传递方式及环境变量这几个方面进行比较。


1、查找方式：前4个函数的查找方式都是完整的文件目录路径 pathname ，而最后两个函数（也就是以p结尾的两个函数）可以只给出文件名filename，系统就会自动按照环境变量“$PATH” 所指定的路径进行查找。

2、参数传递方式：exec 序列函数的参数传递有两种方式：一种是逐个列举的方式，而另一种则是将所有参数整体构造指针数组传递。在这里是以函数名的第5位字母来区分的，字母为 “l”（list）（参数可变，类似printf函数）的表示逐个列举参数的方式，其语法为 const char *arg；字母为 “v”（vertor）的表示将所有参数整体构造指针数组传递，其语法为 char *const argv[]。读者可以观察 execl()、execle()、execlp() 的语法与 execv()、execve()、execvp() 的区别。这里的参数实际上就是用户在使用这个可执行文件时所需的全部命令选项字符串（包括该可执行程序命令本身）。要注意的是，这些参数必须以NULL结束。

3、 环境变量：exec 序列函数可以默认系统的环境变量，也可以传入指定的环境变量。这里以 “e”（environment）结尾的两个函数 execle() 和 execve() 就可以在 envp[] 中指定当前进程所使用的环境变量。

    

表 1 exec 序列函数的总结      
前4位 统一为：exec      
第5位 l：参数传递为逐个列举方式    execl、execle、execlp  
     v：参数传递为构造指针数组方式     execv、execve、execvp  
第6位 e：可传递新进程环境变量     execle、execve  
     p：可执行文件查找方式为文件名     execlp、execvp

        事实上，这6个函数中真正的系统调用只有 execve()，其他5个都是 C 库函数，它们最终都会调用execve() 这个系统调用。在使用 exec 序列函数时，一定要加上错误判断语句。exec 很容易执行失败，其中最常见的原因有：

1、找不到文件或路径，此时 errno 被设置为 ENOENT。

2、 数组 argv 和 envp 忘记用NULL结束，此时，errno 被设置为 EFAUL。

3、没有对应可执行文件的运行权限，此时errno 被设置为EACCES。

/* 执行exec函数，下面属性是不发生变化的： 

*进程ID和父进程ID（pid, ppid） 
*实际用户ID和实际组ID（ruid, rgid） 
*附加组ID（sgid） 
*会话ID 
*控制终端 
*闹钟余留时间 
*当前工作目录 
*根目录 
*umask 
*文件锁 
*进程信号屏蔽 
*未处理信号 
*资源限制 
*进程时间 
*/  
/*而下面属性是发生变化的： 
*文件描述符如果存在close-on-exec标记的话，那么打开的文件描述符会被关闭。 
*如果可执行程序文件存在SUID和SGID位的话，那么有效用户ID和组ID（euid, egid）会发生变化 
*/

         exec 序列函数的关系如下图所示：


测试程序：

#include "apue.h"  
#include <unistd.h>  
#include <sys/wait.h>  
  
char *argv[] = {"echo", "STATUS=testing", "\tHellow linux","\tgood bye",NULL};  
char *argve[] = {"env",NULL};  
char *env[] = {"USER=unknown", "PATH=/tmp",NULL};  
int main()  
{  
    pid_t pid;  
  
    if((pid = fork()) < 0)  /* fork error */  
        err_sys("fork error.");  
    else if(0 == pid)   /* in child process */  
    {  
        if(execl("/bin/ls","ls","-a", "-l", (char *)0) == -1)  
            err_sys("execl error.\n");  
      //  exit(0);  
    }  
  
    if(waitpid(pid, NULL, 0) < 0)  
        err_sys("wait error.");  
    if((pid = fork()) < 0)  /* fork error */  
        err_sys("fork error.");  
    else if(0 == pid)   /* in child process */  
    {  
        if(execlp("ls","ls","-a", "-l", (char *)0) == -1)  
            err_sys("execlp error.\n");  
      //  exit(0);  
    }  
  
    if(waitpid(pid, NULL, 0) < 0)  
        err_sys("wait error.");  
    if((pid = fork()) < 0)  /* fork error */  
        err_sys("fork error.");  
    else if(0 == pid)   /* in child process */  
    {  
        if(execvp("echo", argv) == -1)  
            err_sys("execvp error.\n");  
    }  
  
    if(waitpid(pid, NULL, 0) < 0)  
        err_sys("wait error.");  
    if((pid = fork()) < 0)  /* fork error */  
        err_sys("fork error.");  
    else if(0 == pid)   /* in child process */  
    {  
        if(execve("/usr/bin/env", argve, env) == -1)  
            err_sys("execve error.\n");  
    }  
    exit(0);  
}

输出结果： 

[root@www chapter_8]# ./a.out
总计 56
drwxr-xr-x 2 root root 4096 12-22 14:28 .
drwxr-xr-x 10 root root 4096 12-21 14:28 ..
-rw-r--r-- 1 root root 1523 12-22 14:24 8-10.c
-rw-r--r-- 1 root root  233 12-21 14:36 8-1.c
-rw-r--r-- 1 root root  724 12-21 14:57 8-2.c
-rw-r--r-- 1 root root  989 12-21 15:45 8-3.c
-rw-r--r-- 1 root root  434 12-21 15:52 8-4.c
-rw-r--r-- 1 root root  725 12-21 16:03 8-5.c
-rw-r--r-- 1 root root 1534 12-21 17:06 8-6.c
-rw-r--r-- 1 root root 1240 12-22 13:41 8-7.c
-rw-r--r-- 1 root root  580 12-22 13:48 8-8.c
-rw-r--r-- 1 root root  386 12-22 14:03 8-9.c
-rwxr-xr-x 1 root root 7794 12-22 14:28 a.out
总计 56
drwxr-xr-x 2 root root 4096 12-22 14:28 .
drwxr-xr-x 10 root root 4096 12-21 14:28 ..
-rw-r--r-- 1 root root 1523 12-22 14:24 8-10.c
-rw-r--r-- 1 root root  233 12-21 14:36 8-1.c
-rw-r--r-- 1 root root  724 12-21 14:57 8-2.c
-rw-r--r-- 1 root root  989 12-21 15:45 8-3.c
-rw-r--r-- 1 root root  434 12-21 15:52 8-4.c
-rw-r--r-- 1 root root  725 12-21 16:03 8-5.c
-rw-r--r-- 1 root root 1534 12-21 17:06 8-6.c
-rw-r--r-- 1 root root 1240 12-22 13:41 8-7.c
-rw-r--r-- 1 root root  580 12-22 13:48 8-8.c
-rw-r--r-- 1 root root  386 12-22 14:03 8-9.c
-rwxr-xr-x 1 root root 7794 12-22 14:28 a.out
STATUS=testing  Hellow linux    good bye
USER=unknown
PATH=/tmp
[root@www chapter_8]#

8.12 解释器文件

解释器文件是文本文件，而解析器是可执行的二进制文件。解析器是由解析器文件的第一行指定的，其格式如下：

#!  pathname [optional-argument]  


//pathename 是解释器的绝对路径；  
//optional-argument　是传递给解析器的参数

　　 内核调用　 exec 　函数的进程实际执行的并不是该解释器文件，而是该解释器文件的第一行中　 pathname 　所指定的解释器。注意以下区别：


解释器文件：以#!开头的文本文件。

解释器：解释器文件第一行pathname所指定的程序。

　　下面用exec　函数调用解释器文件例程：注意：以下文件的工作目录为/tmp

　　首先创建解释器echoarg：解释器echoarg由echoarg.c文件编译而成，echoarg.c文件如下所示，实现功能是显示执行程序的参数列表：

#include "apue.h"  
/* 
 * 函数功能：显示执行程序的参数列表； 
 */  
int main(int argc, char *argv[])  
{  
    int i = 0;  
    for(i=0;i<argc;i++)  
        printf("argv[%d]: %s\n",i,argv[i]);  
    exit(0);  
}

　　接着定义解释器文件testintererp（/tmp是工作路径，echoarg是解释器）：这里需要注意，我们创建该文件时，是没有执行权限的，必须更改使其具有可执行权限，最简单的更改就是：

chmod 777 testintererp  

 

#! /tmp/echoarg arg  

　　最后创建包含exec函数调用的文件test.c，并编译成可执行文件test：

#include "apue.h"  
#include <sys/wait.h>  
  
int main(void)  
{  
    pid_t pid;  
  
    if((pid = fork()) < 0)  
        err_sys("fork error");  
    else if(0 == pid)  
    {  
        if(execl("/tmp/testintererp","testintererp","myarg1","myarg2",(char *)0) < 0)  
            err_sys("execl error");  
    }  
    if(waitpid(pid,NULL,0) < 0)  
        err_sys("wait error");  
    exit(0);  
}

　　执行test文件之后输出结果为：

argv[0]: /tmp/echoarg  

argv[1]: arg  

argv[2]: /tmp/testintererp  

argv[3]: myarg1  

argv[4]: myarg2  

8.13 system函数

system 函数能够执行函数中参数的命令，实现如下：

/* system 函数 */ 
#include <stdlib.h> 
int system(const char *cmdstring);

首先我们看下该函数的具体实现： 

/* system 函数的实现 */ 
#include "apue.h" 
#include <sys/wait.h> 
 
int system(const char *cmdstring) 
{ 
   pid_t pid; 
   int status; 
 
   if(NULL == cmdstring) 
       return -1; 
   if((pid = fork()) < 0) 
       status = -1; 
   else if(0 == pid) 
   { 
       execl("/bin/sh", "sh", "-c","cmdstring", (char *)0); 
       _exit(127); 
   } 
   else 
   { 
       while(waitpid(pid,&status,0) < 0) 
       { 
           if(errno != EINTR) 
           { 
                status = -1; 
                break; 
           } 
       } 
   } 
   return status; 
}

　　从该函数的实现我们可以知道，在现有进程中调用 fork 函数创建新的子进程，在 fork 所返回的子进程中调用 execl 函数执行参数字符命令，在 fork 所返回父进程中调用 waitpid 函数等待进程终止；因此有下面的三个返回值：

1、如果 fork 失败或者 waitpid 返回值除 EINTR 之外的出错，则system 返回-1，而且 errno 中设置了错误类型值；

2、如果 exec 失败（表示不能执行shell），其返回值如同 shell 执行 exit(127)一样；

3、否则所有三个函数（fork、exec、waitpid）都执行成功，并且system的返回值是 shell 的终止状态；

测试程序：

 

#include <sys/wait.h> 
#include "apue.h" 
 
void pr_exit(int status) 
{ 
   if(WIFEXITED(status)) 
       printf("normal termination, exit status = %d\n",WEXITSTATUS(status)); 
    else if(WIFSIGNALED(status)) 
       printf("abnormal termination, signal number = %d%s\n",WTERMSIG(status), 
#ifdef WCOREDUMP 
                WCOREDUMP(status) ? "(corefile generated)" : " "); 
#else 
   " "); 
#endif 
 
   else if(WIFSTOPPED(status)) 
       printf("child stoped, signal number = %d\n",WSTOPSIG(status)); 
} 
 
int main(void) 
{ 
   int status; 
 
   if((status = system("date")) < 0) 
       err_sys("system error"); 
   pr_exit(status); 
 
   if((status = system("nosuchcommand")) < 0) 
       err_sys("system error"); 
   pr_exit(status); 
 
   if((status = system("stat;who; exit 44")) < 0) 
       err_sys("system error"); 
   pr_exit(status); 
 
   exit(0); 
}

返回值：

[root@www chapter_8]# ./a.out
2014年 12月 22日 星期一 15:23:28 CST
normal termination, exit status = 0
sh: nosuchcommand: command not found
normal termination, exit status = 127
stat: 缺少操作数
请尝试执行“stat --help”来获取更多信息。
root    :0           2014-12-22 13:13
root    pts/1        2014-12-22 13:13(:0.0)
normal termination, exit status = 44
[root@www chapter_8]#

测试程序2： 

#include <sys/wait.h> 
#include "apue.h" 
 
void pr_exit(int status) 
{ 
   if(WIFEXITED(status)) 
       printf("normal termination, exit status = %d\n",WEXITSTATUS(status)); 
   else if(WIFSIGNALED(status)) 
       printf("abnormal termination, signal number = %d%s\n",WTERMSIG(status), 
#ifdef WCOREDUMP 
                WCOREDUMP(status) ? "(corefile generated)" : " "); 
#else 
   " "); 
#endif 
 
   else if(WIFSTOPPED(status)) 
       printf("child stoped, signal number = %d\n",WSTOPSIG(status)); 
} 
 
int main(int argc, char *argv[]) 
{ 
   int status; 
   if(argc != 2) 
   { 
       printf("usage: a.out <cmdstring>\n"); 
       exit(1); 
   } 
   status = system(argv[1]); 
   pr_exit(status); 
 
   exit(0); 
}

以上程序可以根据自己需要输入要执行的字符命令参数。假设编译成可执行文件a.out，例如输入./ a.out ls，输出如下： 

[root@www chapter_8]# ./a.out ls
8-10.c 8-11.c~  8-13.c  8-2.c 8-4.c  8-6.c  8-8.c a.out
8-11.c 8-12.c   8-1.c   8-3.c 8-5.c  8-7.c  8-9.c
normal termination, exit status = 0

8.16 进程时间

        进程时间（注意区别于文件的三个时间）有墙上时钟时间、用户CPU时间和系统CPU时间。任一进程都可以调用 times 函数以获得它自己以及终止子进程的上述值。

/* 进程时间 */  
  
/* 
 * 函数功能：获取进程的时间：墙上时钟时间、用户CPU时间和系统CPU时间； 
 * 返回值：若成功则返回流逝的墙上时钟时间（单位：时钟滴答数），若出错则返回-1； 
 * 函数原型： 
 */  

#include <sys/times.h>  
clock_t times(struct tms *buf);  
  
/* 
 * struct tms 结构如下： 
 */  
struct tms{  
  
    clock_t tms_utime;  /* user CPU time */  
    clock_t tms_stime;  /* system CPU time */  
    clock_t tms_cutime;  /* user CPU time, terminated children */  
    clock_t tms_cstime;  /* system CPU time, terminated children */  
};

      在进程时间结构 tms 中并没有包含墙上时钟时间的测量值，times 函数返回值可作为墙上时钟时间的测量值，其取值是两次times 返回值的差值。由此函数返回的 clock_t 值都用_SC_CLK_TCK（由 sysconf函数返回的每秒时钟滴答数）变换成秒数。

测试程序：

#include <sys/times.h>  
#include <time.h>  
#include <wait.h>
#include "apue.h"  
  
static void pr_times(clock_t, struct tms *, struct tms *);  
static void do_cmd(char *);  
  
void pr_exit(int status);  
int main(int argc, char *argv[])  
{  
        int i;  
        for(i=1; i<argc; i++){  
                do_cmd(argv[i]);  
        }  
        exit(0);  
}  
  
static void do_cmd(char* cmd)  
{  
        struct tms tmsstart, tmsend;  
        clock_t start, end;  
        int status;  
        printf("\ncommand: %s\n", cmd);  
        if((start=times(&tmsstart)) == -1)  
                err_sys("times error");  
  
        if((status = system(cmd)) < 0)  
                err_sys("system error");  
  
        if((end = times(&tmsend)) == -1)  
                err_sys("times error");  
  
        pr_times(end-start, &tmsstart, &tmsend);  
        pr_exit(status);  
}  
  
static void pr_times(clock_t real, struct tms* tmsstart, struct tms* tmsend)  
{  
        static long clktck = 0;  
        if((clktck = sysconf(_SC_CLK_TCK)) < 0)  
                err_sys("sysconf error");  
        printf("real: %7.2f\n",real/(double)clktck);  
        printf("user: %7.2f\n",(tmsend->tms_utime - tmsstart->tms_utime)/(double)clktck);  
        printf("sys: %7.2f\n",(tmsend->tms_stime - tmsstart->tms_stime)/(double)clktck);  
        printf("child user: %7.2f\n",(tmsend->tms_cutime - tmsstart->tms_cutime)/(double)clktck);  
        printf("child sys: %7.2f\n",(tmsend->tms_cstime - tmsstart->tms_cstime)/(double)clktck);  
}  
void pr_exit(int status)  
{  
    if(WIFEXITED(status))  
        printf("normal termination, exit status = %d\n", WEXITSTATUS(status));  
    else if(WIFSIGNALED(status))  
        printf("abnormal termination, signal number = %d%s\n", WTERMSIG(status),  
#ifdef WCOREDUMP  
                WCOREDUMP(status) ? "(core file generated)" : " ");  
#else  
    " ");  
#endif  
  
    else if(WIFSTOPPED(status))  
        printf("child stoped, signal number = %d\n", WSTOPSIG(status));  
}

输出结果： 

[root@www chapter_8]# ./a.out  date
 
command: date
2014年 12月 22日 星期一 16:09:07 CST
real:   0.01
user:   0.00
sys:   0.00
child user:    0.00
child sys:    0.00
normal termination, exit status = 0

8.17 小结

对于UNIX 环境中的高级编程而言，完整地了解 UNIX 的进程控制是非常重要的。其中必须熟练掌握的只有几个函数——fork 、exec族、_exit、wait和waitpid。很多应用程序都使用这些原语。

思翊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux缺少文件操作数,linux 文件的atime,ctime,mtime查看与修改
weixin_33304613的博客
04-29 2516
查看ls -a默认显示的是修改时间ls -c / --time=status / --time=ctime显示的是状态修改时间(即权限修改时间)ls -u / --time=use / --time=access / --time=atime表示的是文件访问时间修改touch: 缺少了文件操作数请尝试执行“touch --help”来获取更多信息。[wei@localhost ~]$ touch ...
《UNIX环境高级编程》笔记 第八章-进程控制
Nick_Di的博客
10-28 586
1. 进程标识 每个进程都用一个唯一的非负整数标识，即为进程id：pid。进程ID是可以复用的，当一个进程终止时，其进程ID就可以用来标识其他进程。 系统中有一些专用进程： ID为0的进程称为调度进程（也称为交换进程swapper）。该进程为内核的一部分，他并不执行任何磁盘上的程序，因此也被称为系统进程 idle 进程或因为历史的原因叫做swapper进程。它是在 linux 的初始化阶段从无到有的创建的一个内核线程。这个祖先进程使用静态分配的数据结构。 在多处理器系统中，每个CPU都有一个进程0，主要
搭建Gitlab 出现 stat --printf(“%U“) (xxxx) = 1 的问题
Wahuqeirdace的专栏
03-21 543
原因： 搭建Gitlab后，系统中会增加用户组git 及用户git，当gitlab需要操作的目录的权限组和用户不是git:git 时，就出现此问题，如切换git 数据存储路径。 解决办法： chown -R git:git 目标目录 在解决问题过程中，出现一个问题和大家分享: 当linux分区的文件系统不是Linux特有时，chown无效， 当时由于空间不足，增加...
linux 使用chmod 777，出现缺少操作数问题。
qq_45080128的博客
12-26 5811
原因：格式不正确 正确写法：chmod 777 ‘程序名无后缀’ 如：chmod 777 ‘pthread’
UNIX环境高级编程习题——第八章
kingolie的博客
08-28 1607
8.1 在图8-3 程序中，如果exit调用替代_exit调用，那么可能会使标准输出关闭，使printf返回-1.修改该程序以验证你所使用的系统上是否会产生这种错误。如果并非如此，你怎样处理才能得到类似结果呢？ 为了方针子进程终止时关闭标准输出的行为，在调用exit之前加入下列代码行： fclose(stdout); /*******************************
UNIX环境高级编程第二版+代码
02-22
《UNIX环境高级编程》是UNIX系统编程领域的一本经典之作，尤其对于第二版，它更加深入地探讨了在UNIX操作系统上进行系统级编程的各种技术。这本书不仅覆盖了基础的编程概念，如文件I/O和进程控制，还涉及了更复杂的...
UNIX环境高级编程-中文第三版
06-13
书中除了介绍UNIX文件和目录、标准I／O库、系统数据文件和信息、进程环境、进程控制、进程关系、信号、线程、线程控制、守护进程、各种I／O、进程间通信、网络IPC、伪终端等方面的内容外，还介绍了众多应用实例，...
UNIX环境高级编程课后习题详细解答
04-10
"UNIX环境高级编程"通常涵盖的主题包括进程管理、文件I/O、信号处理、网络编程、系统调用接口以及内存管理等。 课后习题往往旨在巩固和深化对这些概念的理解。以下是一些可能涉及的知识点： 1. **进程管理**：包括...
Unix环境高级编程中英文版包括源代码
04-07
《UNIX环境高级编程中文版.pdf》可能是第一版或第二版的中文翻译，尽管版本不同，但核心知识点与第三版应大体一致。 通过学习《Unix环境高级编程》，读者可以掌握以下关键知识点： 1. **Unix系统接口**：包括系统...
关于线程编程中“undefined reference to 'pthread_create'等问题的解决
灯火阑珊处
01-04 869
今天学习UNIX环境高级编程第11章中的线程编程，在编译第一个demo时，出现了“undefined reference to ‘pthread_create’”这种错误导致无法编译通过。 问题的原因：pthread 库不是 Linux 系统默认的库，连接时需要使用静态库 libpthread.a，所以在使用pthread_create()创建线程，以及调用 pthread_atfork()
UNIX环境高级编程-第16章- 网络IPC：套接字 - 二
灯火阑珊处
01-13 722
在基于 TCP 的通信连接请求过程有三次握手，其过程如下所示：        第一次握手：客户端发送syn包(seq=x)到服务器，并进入SYN_SEND状态，等待服务器确认；        第二次握手：服务器收到syn包，必须确认客户的SYN（ack=x+1），同时自己也发送一个SYN包（seq=y），即SYN+ACK包，此时服务器进入SYN_RECV状态；        第三次握
UNIX环境高级编程-第9章- 进程关系
灯火阑珊处
12-23 709
9.4 进程组  在UNIX 系统中，每个进程除了自己的进程 ID之外，还属于一个进程组。进程组是一个进程或多个进程的集合，进程组本身也有属于自己的进程组ID，进程组属于一个会话，fork()并不改变进程组ID。 进程组组长：         进程ID与进程组ID相等的进程。组长可以改变子进程的进程组ID，使其转移到另一进程组。组长进程可以在所在的进程组创建进程，然后终止，从进程组创建开始到
I/O多路复用技术之 - epoll
灯火阑珊处
01-24 678
1、基础知识 　　epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。 2、epoll接口 　　epoll操作过程需要三个接口，分别如下： #include
UNIX环境高级编程-第17章- 高级进程间通信 - 一
灯火阑珊处
01-14 659
17.1 引言        前面两章介绍了UNIX系统提供的各种IPC，包括管道和套接字。本章介绍两种高级IPC：基于STREAM的管道和UNIX域套接字，并说明它们的应用方法。前面介绍的管道是半双工管道，本章基于 STREAMS 的管道是属于全双工的管道，半双工和全双工管道的区别如下：半双工只能在一端进行读或写；全双工可以在某一端同时进行读写；   17.2 基于 STREAMS
UNIX环境高级编程-第15章- 进程间通信 - 一
灯火阑珊处
01-10 637
15.1 引言 进程通信（IPC）是处理一个多进程系统中各个进程之间的协调。进程通信就是指多个进程之间相互通信、交换信息的方法。进程通信的目的如下： （1）数据传输：一个进程需要将它的数据发送给另一个进程； （2）共享数据：多个进程操作共享数据，若其中一个进程修改了共享数据，则其他进程立即可以看到修改后的数据； （3）通知事件：一个进程要向另一个或一组进程发送消息，通知它们发生了某种事，例
UNIX环境高级编程-第7章- 进程环境
灯火阑珊处
12-20 622
7.2 main 函数          C程序总是从 main 函数开始执行。main 函数的原型是          int main ( int argc , char * argv[] ); 其中，argc 是命令行参数的数目，argv 是指向参数的各个指针所构成的数组。 当内核执行C程序时（使用一个exec函数执行），在调用mian函数前先调用一个特殊的启动例程。可执行程序文
UNIX环境高级编程-第8章- 进程控制 - 一
灯火阑珊处
12-21 616
8.3 fork 函数 在 UNIX 系统中，一个现有进程可以调用 fork 函数创建一个新进程。调用 fork 函数的进程称为父进程，由 fork 创建的新进程被称为子进程（child process）。fork函数被调用一次但返回两次，两次返回的唯一区别是子进程中返回0值而父进程中返回子进程ID。首先看下fork函数的原型； /* 创建进程 */ /* fork 函数 */
I/O多路复用技术之 - select
灯火阑珊处
01-24 594
当我们想要多次对描述符进行read 时，多路转接技术能够满足该要求。I/O 多路转接技术首先构造一张有关描述符的列表，然后调用一个函数，直到这些描述符中的一个已准备好进行 I/O 时，该函数才返回，返回时，告诉进程哪些描述符已经准备好可以进行 I/O 操作。 1、基本概念 　　IO多路复用是指内核一旦发现进程指定的一个或者多个I/O条件准备读取，它就通知该进程。IO多路复用适用如下场合：
Unix环境高级编程：第二版
"《Unix环境高级编程》第二版，作者W. Richard Stevens和Stephen A. Rago，由Addison Wesley Professional出版社于2005年6月出版，ISBN:0201433079，共960页。这本书是Unix和类Unix操作系统开发者的必备参考书，全面...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值