Chinaunix首页 | 论坛 | 博客
  • 博客访问: 293948
  • 博文数量: 134
  • 博客积分: 667
  • 博客等级: 上士
  • 技术积分: 770
  • 用 户 组: 普通用户
  • 注册时间: 2012-04-08 15:19
文章分类

全部博文(134)

文章存档

2012年(134)

分类:

2012-04-08 16:28:30

原文地址:进程同步 作者:yulianliu1218

进程同步

2.1 父子进程:每一个进程都有一个父进程,父进程通过调用fork()函数产生子进程,当子进程结束终止时,父进程会得到子进程退出的状态。

 

2.2 进程组:每个进程除了有一个进程ID外还属于一个进程组,一个进程组是一个或者多个进程的集合,它分为前台进程组和后台进程组,每个进程组都有一个唯一的组ID,进程组ID类似于进程ID,是一个正整数,可以用pid_t表示,具体函数看一下链接。

http://blog.chinaunix.net/space.php?uid=25324849&do=blog&id=207249

每个进程组有一个组长ID即是进程组ID,进程组长可以创建进程组,只要一个进程组有一个进程存在,进程组就存在。

某进程组中最后一个进程可以终止或者加入另外一个进程组里面,具体函数见

http://blog.chinaunix.net/space.php?uid=25324849&do=blog&id=207259

 

2.3会话期:一个会话是一个或者多个进程组的集合,但是只能有一个前台进程组,一次登录就形成了一个会话。

调用函数setsid建立新的会话,具体用法见:

http://blog.chinaunix.net/space.php?uid=25324849&do=blog&id=207259

2.4 控制终端:会话的组织打开一个终端之后,该终端就成为该会话的控制终端,与控制终端建立连接的组长进程称为控制进程。

注意:一个会话只能有一个控制终端,产生在控制终端上的输入和输出信号都会发送到会话的前台进程组所有的进程里面。

 

注意:如果当前进程进程组长或者会话组长终止,那么进程组ID或者会话的控制终端会改变会改变??

 

3.  信号处理

信号是在软件层次上对中断机制的一种模拟,在原理上,一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的,一个进程不必通过任何操作来等待信号的到达,事实上,进程也不知道信号到底什么时候到达。信号是进程间通信机制中唯一的异步通信机制,可以看作是异步通知,通知接收信号的进程有哪些事情发生了。信号机制经过POSIX实时扩展后,功能更加强大,除了基本通知功能外,还可以传递附加信息。

信号事件的发生有两个来源:硬件来源(比如我们按下了键盘或者其它硬件故障);软件来源,最常用发送信号的系统函数是kill, raise, alarmsetitimer以及sigqueue函数,软件来源还包括一些非法运算等操作。

3.1信号的种类

可以从两个不同的分类角度对信号进行分类:(1)可靠性方面:可靠信号与不可靠信号;(2)与时间的关系上:实时信号与非实时信号。在《Linux环境进程间通信(一):管道及有名管道》的附1中列出了系统所支持的所有信号。

3.2可靠信号与不可靠信号

3.2.1  "不可靠信号"

Linux信号机制基本上是从Unix系统中继承过来的。早期Unix系统中的信号机制比较简单和原始,后来在实践中暴露出一些问题,因此,把那些建立在早期机制上的信号叫做"不可靠信号",信号值小于SIGRTMIN(Red hat 7.2中,SIGRTMIN=32SIGRTMAX=63)的信号都是不可靠信号。这就是"不可靠信号"的来源。它的主要问题是:

·  进程每次处理信号后,就将对信号的响应设置为默认动作。在某些情况下,将导致对信号的错误处理;因此,用户如果不希望这样的操作,那么就要在信号处理函数结尾再一次调用signal(),重新安装该信号。

·  信号可能丢失,后面将对此详细阐述。
因此,早期unix下的不可靠信号主要指的是进程可能对信号做出错误的反应以及信号可能丢失。

Linux支持不可靠信号,但是对不可靠信号机制做了改进:在调用完信号处理函数后,不必重新调用该信号的安装函数(信号安装函数是在可靠机制上的实现)。因此,Linux下的不可靠信号问题主要指的是信号可能丢失。

3.2.2 "可靠信号"

随着时间的发展,实践证明了有必要对信号的原始机制加以改进和扩充。所以,后来出现的各种Unix版本分别在这方面进行了研究,力图实现"可靠信号"。由于原来定义的信号已有许多应用,不好再做改动,最终只好又新增加了一些信号,并在一开始就把它们定义为可靠信号,这些信号支持排队,不会丢失。同时,信号的发送和安装也出现了新版本:信号发送函数sigqueue()及信号安装函数sigaction()POSIX.4对可靠信号机制做了标准化。但是,POSIX只对可靠信号机制应具有的功能以及信号机制的对外接口做了标准化,对信号机制的实现没有作具体的规定。

可靠信号克服了信号可能丢失的问题。Linux在支持新版本的信号安装函数sigation()以及信号发送函数sigqueue()的同时,仍然支持早期的signal()信号安装函数,支持信号发送函数kill()

但应注意的是:信号的可靠与不可靠只与信号值有关,与信号的发送及安装函数无关。

信号值小于SIGRTMIN的信号为不可靠信号,信号值在SIGRTMINSIGRTMAX之间的信号为可靠信号。

3.3   实时信号与非实时信号

早期Unix系统只定义了32种信号,Ret hat7.2支持64种信号,编号0-63(SIGRTMIN=31SIGRTMAX=63),将来可能进一步增加,这需要得到内核的支持。前32种信号已经有了预定义值,每个信号有了确定的用途及含义,并且每种信号都有各自的缺省动作。如按键盘的CTRL ^C时,会产生SIGINT信号,对该信号的默认反应就是进程终止。后32个信号表示实时信号,等同于前面阐述的可靠信号。这保证了发送的多个实时信号都被接收。实时信号是POSIX标准的一部分,可用于应用进程。

非实时信号都不支持排队,都是不可靠信号;实时信号都支持排队,都是可靠信号。

进程对信号的响应

进程可以通过三种方式来响应一个信号:(1)忽略信号,即对信号不做任何处理,其中,有两个信号不能忽略:SIGKILLSIGSTOP;(2)捕捉信号。定义信号处理函数,当信号发生时,执行相应的处理函数;(3)执行缺省操作,Linux对每种信号都规定了默认操作,详细情况请参考[2]以及其它资料。注意,进程对实时信号的缺省反应是进程终止。Linux究竟采用上述三种方式的哪一个来响应信号,取决于传递给相应API函数的参数。

3.5   信号的发送

发送信号的主要函数有:kill()raise() sigqueue()alarm()setitimer()以及abort()

3.5.1   kill()函数

#include

#include

int kill(pid_t pid,int signo)

参数pid的值

信号的接收进程

pid>0

进程IDpid的进程

pid=0

同一个进程组的进程

pid<0 pid!=-1

进程组ID -pid的所有进程

pid=-1

除发送进程自身外,所有进程ID大于1的进程

Sinno是信号值,当为0时(即空信号),实际不发送任何信号,但照常进行错误检查,因此,可用于检查目标进程是否存在,以及当前进程是否具有向目标发送信号的权限(root权限的进程可以向任何进程发送信号,非root权限的进程只能向属于同一个session或者同一个用户的进程发送信号)。

Kill()最常用于pid>0时的信号发送,调用成功返回 0; 否则,返回 -1。注:对于pid<0时的情况,对于哪些进程将接受信号,各种版本说法不一,其实很简单,参阅内核源码kernal/signal.c即可,上表中的规则是参考red hat 7.2

3.5.2   raise()函数

#include

int raise(int signo)

向进程本身发送信号,参数为即将发送的信号值。调用成功返回 0;否则,返回 -1

3.5.3   alarm()函数

unsigend int alarm(unsigend int seconds)

seconds:定时器设置的秒数

返回值:为尚未过期的定时器秒数

3.5.4   abort()函数

#include
void abort(void);

向进程发送SIGABORT信号,默认情况下进程会异常退出,当然可定义自己的信号处理函数。即使SIGABORT被进程设置为阻塞信号,调用abort()后,SIGABORT仍然能被进程接收。该函数无返回值。

3.5.4  setitimer()函数

#include

int getitimer(int which, struct itimerval *value);

int setitimer(int which, struct const struct itimerval *value,

struct itimerval *ovalue)

setitimer函数定时精度要比alarm函数高,同时可以按照进程的执行时间(用户态时间,核心态时间,或者两者)进行计时。

信号的安装(设置信号关联动作)

如果进程要处理某一信号,那么就要在进程中安装该信号。安装信号主要用来确定信号值及进程针对该信号值的动作之间的映射关系,即进程将要处理哪个信号;该信号被传递给进程时,将执行何种操作。

linux主要有两个函数实现信号的安装:signal()sigaction()。其中signal()在可靠信号系统调用的基础上实现是库函数。它只有两个参数,不支持信号传递信息,主要是用于前32种非实时信号的安装;而sigaction()是较新的函数(由两个系统调用实现:sys_signal以及sys_rt_sigaction),有三个参数,支持信号传递信息,主要用来与 sigqueue() 系统调用配合使用,当然,sigaction()同样支持非实时信号的安装。sigaction()优于signal()主要体现在支持信号带有参数。

3.6.1    signal()
#include

void (*signal(int signum, void (*handler))(int)))(int);

如果该函数原型不容易理解的话,可以参考下面的分解方式来理解:

typedef void (*sighandler_t)(int)

sighandler_t signal(int signum, sighandler_t handler));

第一个参数指定信号的值,第二个参数指定针对前面信号值的处理,可以忽略该信号(参数设为SIG_IGN);可以采用系统默认方式处理信号(参数设为SIG_DFL);也可以自己实现处理方式(参数指定一个函数地址)

如果signal()调用成功,返回最后一次为安装信号signum而调用signal()时的handler值;失败则返回SIG_ERR

3.6.2   sigaction()
#include

int sigaction(int signum,const struct sigaction *act,struct sigaction *oldact));

sigaction函数用于改变进程接收到特定信号后的行为。该函数的第一个参数为信号的值,可以为除SIGKILLSIGSTOP外的任何一个特定有效的信号(为这两个信号定义自己的处理函数,将导致信号安装错误)。第二个参数是指向结构sigaction的一个实例的指针,在结构sigaction的实例中,指定了对特定信号的处理,可以为空,进程会以缺省方式对信号处理;第三个参数oldact指向的对象用来保存原来对相应信号的处理,可指定oldactNULL。如果把第二、第三个参数都设为NULL,那么该函数可用于检查信号的有效性。第二个参数最为重要,其中包含了对指定信号的处理、信号所传递的信息、信号处理函数执行过程中应屏蔽掉哪些函数等等。

    信号是软件中断。很多比较重要的应用程序都需要处理信号。信号提供了一种处理异步事件的方法.每个信号都有一个名字,这些名字都以三个字符SIG开头。在头文件中,这些信号都被定义为正整数(信号编号)。

   

很多条件可以产生一个信号。

1.当用户按某些终端键时,产生信号。如:用户按ctrl+c 产生中断信号,中止当前进程。

2.硬件异常产生信号。如:除数为0,无效的存储访问等等。这些条件通常由硬件检测到,并将其通知内核。然后内核为该条件发生时正在运行的进程产生适当的信号。

3.进程用kill(1) 命令将信号发送给另一个进程或进程组。自然,有些限制:按收信号进程和发送信号进程的所有这者必须相同,或发送信号的所有者必须是超级用户。

4.用户可用kill(1) 命令将信号发送给其他进程。此程序是kill函数的界面,常用此命名终止一个失控的后台进程。

5.当检测到某种软件条件已经发生,并将其通知有关进程时也产生信号。

 

Redhatkill -l 得到:

      1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL

      5) SIGTRAP      6) SIGABRT      7) SIGBUS       8) SIGFPE

      9) SIGKILL     10) SIGUSR1     11) SIGSEGV     12) SIGUSR2

     13) SIGPIPE     14) SIGALRM     15) SIGTERM     17) SIGCHLD

     18) SIGCONT     19) SIGSTOP     20) SIGTSTP     21) SIGTTIN

     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ

     26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO

     30) SIGPWR      31) SIGSYS      32) SIGRTMIN    33) SIGRTMIN+1

     34) SIGRTMIN+2  35) SIGRTMIN+3  36) SIGRTMIN+4  37) SIGRTMIN+5

     38) SIGRTMIN+6  39) SIGRTMIN+7  40) SIGRTMIN+8  41) SIGRTMIN+9

     42) SIGRTMIN+10 43) SIGRTMIN+11 44) SIGRTMIN+12 45) SIGRTMIN+13

     46) SIGRTMIN+14 47) SIGRTMIN+15 48) SIGRTMAX-15 49) SIGRTMAX-14

     50) SIGRTMAX-13 51) SIGRTMAX-12 52) SIGRTMAX-11 53) SIGRTMAX-10

     54) SIGRTMAX-9  55) SIGRTMAX-8  56) SIGRTMAX-7  57) SIGRTMAX-6

     58) SIGRTMAX-5  59) SIGRTMAX-4  60) SIGRTMAX-3  61) SIGRTMAX-2

     62) SIGRTMAX-1  63) SIGRTMAX

 

3.7处理僵死进程

如果子进程在父进程之前终止,系统内核会为每个子进程保存一定量的信息,所以终止进程的父进程应调用wait()waitpid()函数来获取子进程终止信息并且释放它仍然占的资源否则终止的子进程就会成为僵死进程,在大量进程时这种情况会很严重。

 

处理僵死进程实例:(父进程必须调用wait()waitpid()函数)

 

// server.c

    #include           /* These are the usual header files */

    #include           /* for bzero() */

    #include          /* for close() */

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #include

 

    #define PORT 1234   /* Port that will be opened */

    #define BACKLOG 2   /* Number of allowed connections */

    #define MAXDATASIZE 1000 

 

    void process_cli(int connectfd, sockaddr_in client);

    void sig_handler(int s);

 

int     main()

    {

    int listenfd, connectfd; /* socket descriptors */

    pid_t pid;

    struct sockaddr_in server; /* server's address information */

    struct sockaddr_in client; /* client's address information */

    socklen_t sin_size;

 

    struct sigaction    act, oact;

    act.sa_handler = sig_handler;

    sigemptyset(&act.sa_mask);

    act.sa_flags = 0;

    // SIGCHLD子进程停止或者终止产生该信号

    if (sigaction(SIGCHLD, &act, &oact) < 0) {

       perror("Sigaction failed!");

       exit(1);

       }

 

    /* Create TCP socket  */

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)

    {

       /* handle exception */

       perror("Creating socket failed.");

       exit(1);

    }

 

    int opt = SO_REUSEADDR;

    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

 

    bzero(&server,sizeof(server));

    server.sin_family=AF_INET;

    server.sin_port=htons(PORT);

    server.sin_addr.s_addr = htonl (INADDR_ANY);

    if (bind(listenfd, (struct sockaddr *)&server, sizeof(struct sockaddr)) == -1) {

       /* handle exception */

       perror("Bind error.");

       exit(1);

       }   

 

    if(listen(listenfd,BACKLOG) == -1){  /* calls listen() */

       perror("listen() error\n");

       exit(1);

       }

 

    sin_size=sizeof(struct sockaddr_in);

    while(1)

    {

       /* accept connection */

       if ((connectfd = accept(listenfd,(struct sockaddr *)&client,&sin_size))==-1) {

          if (errno == EINTR) continue;

          perror("accept() error\n");

          exit(1);

          }

       /*  create child process */

       if ((pid=fork())>0) {

          /* parent process */

          close(connectfd);

          continue;

          }

       else if (pid==0) {

          /* child process */

          close(listenfd);

          process_cli(connectfd, client);

          exit(0);    

       }

       else {

          printf("fork error\n");

          exit(0);

          }

    }

    close(listenfd);   /* close listenfd */        

    }

 

    void process_cli(int connectfd, sockaddr_in client)

    {

    int num;

    char recvbuf[MAXDATASIZE], sendbuf[MAXDATASIZE], cli_name[MAXDATASIZE];

 

    printf("You got a connection from %s.  ",inet_ntoa(client.sin_addr) );

    /* Get client's name from client */

    num = recv(connectfd, cli_name, MAXDATASIZE,0);

    if (num == 0) {

       close(connectfd);

       printf("Client disconnected.\n");

       return;

       }

    cli_name[num - 1] = '\0';

    printf("Client's name is %s.\n",cli_name);

 

    while (num = recv(connectfd, recvbuf, MAXDATASIZE,0)) {

       recvbuf[num] = '\0';

       printf("Received client( %s ) message: %s",cli_name, recvbuf);

       for (int i = 0; i < num - 1; i++) {

          sendbuf[i] = recvbuf[num - i -2];

      }

   sendbuf[num - 1] = '\0';

   send(connectfd,sendbuf,strlen(sendbuf),0);

   }

 close(connectfd); /*  close connectfd */

 }

 

 void sig_handler(int s)

 {

    pid_t   pid;

    int     stat;

//不断处理 直到没有要处理的子进程为止

    while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0)

   printf("child %d terminated\n", pid);

       return;

}

 

 

// client.c

    #include

    #include

    #include

    #include

    #include

    #include

    #include         /* netbd.h is needed for struct hostent =) */

    #include

 

    #define PORT 1234   /* Open Port on Remote Host */

    #define MAXDATASIZE 100   /* Max number of bytes of data */

    void process(FILE *fp, int sockfd);

    char* getMessage(char* sendline,int len, FILE* fp);

 

    int main(int argc, char *argv[])

    {

    int fd;   /* files descriptors */

    struct hostent *he;         /* structure that will get information about remote host */

    struct sockaddr_in server;  /* server's address information */

 

    if (argc !=2) {      

       printf("Usage: %s \n",argv[0]);

       exit(1);

       }

 

    if ((he=gethostbyname(argv[1]))==NULL){ /* calls gethostbyname() */

       printf("gethostbyname() error\n");

       exit(1);

       }

 

    if ((fd=socket(AF_INET, SOCK_STREAM, 0))==-1){  /* calls socket() */

       printf("socket() error\n");

       exit(1);

       }

 

    bzero(&server,sizeof(server));

    server.sin_family = AF_INET;

    server.sin_port = htons(PORT); /* htons() is needed again */

    server.sin_addr = *((struct in_addr *)he->h_addr); 

 

    if(connect(fd, (struct sockaddr *)&server,sizeof(struct sockaddr))==-1){ /* calls connect() */

       printf("connect() error\n");

       exit(1);

       }

 

    process(stdin,fd);

 

    close(fd);   /* close fd */ 

    }

 

    void process(FILE *fp, int sockfd)

    {

    char    sendline[MAXDATASIZE], recvline[MAXDATASIZE];

    int numbytes;

 

    printf("Connected to server. \n");

    /* send name to server */

    printf("Input name : ");

    if ( fgets(sendline, MAXDATASIZE, fp) == NULL) {

       printf("\nExit.\n");

       return;

       }

    send(sockfd, sendline, strlen(sendline),0);

 

    /* send message to server */ 

    while (getMessage(sendline, MAXDATASIZE, fp) != NULL) {

       send(sockfd, sendline, strlen(sendline),0);

 

       if ((numbytes = recv(sockfd, recvline, MAXDATASIZE,0)) == 0) {

          printf("Server terminated.\n");

          return;

          }

 

       recvline[numbytes]='\0';

       printf("Server Message: %s\n",recvline); /* it prints server's welcome message  */

 

       }

    printf("\nExit.\n");

    }

 

    char* getMessage(char* sendline,int len, FILE* fp)

    {

    printf("Input string to server:");

    return(fgets(sendline, MAXDATASIZE, fp));

    }

 

阅读(535) | 评论(0) | 转发(0) |
0

上一篇:进程关系

下一篇:进程环境

给主人留下些什么吧!~~