應用C說話的fork()函數在Linux中創立過程的實例講授。本站提示廣大學習愛好者：（應用C說話的fork()函數在Linux中創立過程的實例講授）文章只能為提供參考，不一定能成為您想要的結果。以下是應用C說話的fork()函數在Linux中創立過程的實例講授正文
在Linux中創立一個新過程的獨一辦法是應用fork()函數。fork()函數是Linux中一個異常主要的函數，和以往碰到的函數有一些差別，由於fork()函數看起來履行一次卻前往兩個值。
fork()函數用於從已存在的過程中創立一個新過程。新過程稱為子過程，而園過程稱為父過程。應用fork()函數獲得的子過程是父過程的一個復成品，它從父過程處繼續了全部過程的地址空間，包含過程的高低文、代碼段、過程客棧、內存信息、翻開的文件描寫符、符號掌握設定、過程優先級、過程組號、以後任務目次、根目次、資本限制和掌握終端等，而子過程所獨有的只要它的過程號、資本應用和計時器等。
由於子過程簡直是父過程的完整復制，所以父子兩過程會運轉統一個法式。這就須要用一種方法來辨別它們，並使它們照此運轉，不然，這兩個過程弗成能做分歧的事。現實上是在父過程中履行fork()函數時，父過程會復制一個子過程，並且父子過程的代碼從fork()函數的前往開端分離在兩個地址空間中同時運轉，從而使兩個過程分離取得所屬fork()函數的前往值，個中在父過程中的前往值是子過程的過程號，而在子過程中前往0。是以，可以經由過程前往值來斷定該過程的父過程照樣子過程。
同時可以看出，應用fork()函數的價值是很年夜的，它復制了父過程中的代碼段、數據段和客棧段裡的年夜部門內容，使得fork()函數的體系開支比擬年夜，並且履行速度也不是很快。
fork()函數語法
fork()函數失足能夠有兩種緣由：
1、以後的過程數曾經到達了體系劃定的下限，這時候errno的值被設置為EAGAIN
2、體系內存缺乏，這時候errno的值被設置為ENOMEM
示例
上面的是csapp.h頭文件，前面的評論辯論中均只用該頭文件來完成法式的編寫。
/* $begin csapp.h */
#ifndef __CSAPP_H__
#define __CSAPP_H__
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <setjmp.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <errno.h>
#include <math.h>
#include <pthread.h>
#include <semaphore.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/* Default file permissions are DEF_MODE & ~DEF_UMASK */
/* $begin createmasks */
#define DEF_MODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH
#define DEF_UMASK S_IWGRP|S_IWOTH
/* $end createmasks */
/* Simplifies calls to bind(), connect(), and accept() */
/* $begin sockaddrdef */
typedef struct sockaddr SA;
/* $end sockaddrdef */
/* Persistent state for the robust I/O (Rio) package */
/* $begin rio_t */
#define RIO_BUFSIZE 8192
typedef struct {
int rio_fd; /* Descriptor for this internal buf */
int rio_cnt; /* Unread bytes in internal buf */
char *rio_bufptr; /* Next unread byte in internal buf */
char rio_buf[RIO_BUFSIZE]; /* Internal buffer */
} rio_t;
/* $end rio_t */
/* External variables */
extern int h_errno; /* Defined by BIND for DNS errors */
extern char **environ; /* Defined by libc */
/* Misc constants */
#define MAXLINE 8192 /* Max text line length */
#define MAXBUF 8192 /* Max I/O buffer size */
#define LISTENQ 1024 /* Second argument to listen() */
/* Our own error-handling functions */
void unix_error(char *msg);
void posix_error(int code, char *msg);
void dns_error(char *msg);
void app_error(char *msg);
/* Process control wrappers */
pid_t Fork(void);
void Execve(const char *filename, char *const argv[], char *const envp[]);
pid_t Wait(int *status);
pid_t Waitpid(pid_t pid, int *iptr, int options);
void Kill(pid_t pid, int signum);
unsigned int Sleep(unsigned int secs);
void Pause(void);
unsigned int Alarm(unsigned int seconds);
void Setpgid(pid_t pid, pid_t pgid);
pid_t Getpgrp();
/* Signal wrappers */
typedef void handler_t(int);
handler_t *Signal(int signum, handler_t *handler);
void Sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
void Sigemptyset(sigset_t *set);
void Sigfillset(sigset_t *set);
void Sigaddset(sigset_t *set, int signum);
void Sigdelset(sigset_t *set, int signum);
int Sigismember(const sigset_t *set, int signum);
/* Unix I/O wrappers */
int Open(const char *pathname, int flags, mode_t mode);
ssize_t Read(int fd, void *buf, size_t count);
ssize_t Write(int fd, const void *buf, size_t count);
off_t Lseek(int fildes, off_t offset, int whence);
void Close(int fd);
int Select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
struct timeval *timeout);
int Dup2(int fd1, int fd2);
void Stat(const char *filename, struct stat *buf);
void Fstat(int fd, struct stat *buf) ;
/* Memory mapping wrappers */
void *Mmap(void *addr, size_t len, int prot, int flags, int fd, off_t offset);
void Munmap(void *start, size_t length);
/* Standard I/O wrappers */
void Fclose(FILE *fp);
FILE *Fdopen(int fd, const char *type);
char *Fgets(char *ptr, int n, FILE *stream);
FILE *Fopen(const char *filename, const char *mode);
void Fputs(const char *ptr, FILE *stream);
size_t Fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
void Fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
/* Dynamic storage allocation wrappers */
void *Malloc(size_t size);
void *Realloc(void *ptr, size_t size);
void *Calloc(size_t nmemb, size_t size);
void Free(void *ptr);
/* Sockets interface wrappers */
int Socket(int domain, int type, int protocol);
void Setsockopt(int s, int level, int optname, const void *optval, int optlen);
void Bind(int sockfd, struct sockaddr *my_addr, int addrlen);
void Listen(int s, int backlog);
int Accept(int s, struct sockaddr *addr, socklen_t *addrlen);
void Connect(int sockfd, struct sockaddr *serv_addr, int addrlen);
/* DNS wrappers */
struct hostent *Gethostbyname(const char *name);
struct hostent *Gethostbyaddr(const char *addr, int len, int type);
/* Pthreads thread control wrappers */
void Pthread_create(pthread_t *tidp, pthread_attr_t *attrp,
void * (*routine)(void *), void *argp);
void Pthread_join(pthread_t tid, void **thread_return);
void Pthread_cancel(pthread_t tid);
void Pthread_detach(pthread_t tid);
void Pthread_exit(void *retval);
pthread_t Pthread_self(void);
void Pthread_once(pthread_once_t *once_control, void (*init_function)());
/* POSIX semaphore wrappers */
void Sem_init(sem_t *sem, int pshared, unsigned int value);
void P(sem_t *sem);
void V(sem_t *sem);
/* Rio (Robust I/O) package */
ssize_t rio_readn(int fd, void *usrbuf, size_t n);
ssize_t rio_writen(int fd, void *usrbuf, size_t n);
void rio_readinitb(rio_t *rp, int fd);
ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n);
ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen);
/* Wrappers for Rio package */
ssize_t Rio_readn(int fd, void *usrbuf, size_t n);
void Rio_writen(int fd, void *usrbuf, size_t n);
void Rio_readinitb(rio_t *rp, int fd);
ssize_t Rio_readnb(rio_t *rp, void *usrbuf, size_t n);
ssize_t Rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen);
/* Client/server helper functions */
int open_clientfd(char *hostname, int portno);
int open_listenfd(int portno);
/* Wrappers for client/server helper functions */
int Open_clientfd(char *hostname, int port);
int Open_listenfd(int port);
#endif /* __CSAPP_H__ */
/* $end csapp.h */
fork()函數示例一
#include "csapp.h"
int main()
{
pid_t pid;
int x=1;
pid=fork();
if(pid==0) {
printf("child :x=%d\n",++x);
exit(0);
}
printf("parent:x=%d\n",--x);
exit(0);
}
例如下面的法式，因為fork()函數比擬特別，履行一次，前往兩次。前往兩次分離是在父過程和子過程中各前往一個值，在子過程中前往為0，在父過程中前往過程ID，普通為正整數即非零。如許就可以依據前往值來肯定其在哪一個過程中了。如下面的法式，子過程中pid=0，所以履行if語句，子過程會同享父過程的文本/數據/bss段/堆和用戶棧，子過程隨後正常終止而且前往碼為0，是以子過程不履行後續的同享代碼塊，是以本法式的輸入成果是
parent:x=0
child :x=2
fork()函數示例二
#include "csapp.h"
int main()
{
if(fork()==0) {
printf("a");
}
else {
printf("b");
waitpid(-1,NULL,0);
}
printf("c");
exit(0);
}
此法式是用來磨練子過程與父過程的關系。異樣再次強調一遍，fork()函數用於新建子過程，子過程具有與父過程雷同的用戶級虛擬地址空間，包含文本/數據/bss段/堆/用戶棧，子過程可以讀寫隨意率性父過程翻開的文件，它們的最年夜差別是它們有分歧的PID。fork函數挪用一次，前往兩次，一次在父過程中，其前往子過程的PID；在子過程中，fork前往0，由於子過程的PID老是非零的，前往值就供給了一個明白的辦法來鑒別是在父過程中履行照樣在子過程中履行。waitpid()函數是期待子過程終止，若無毛病，則前往值為負數。由於在在子過程中，fork()前往0，是以先輸入a，而且其同享父過程的代碼段，故又輸入c；而在父過程中，fork()前往值非零，所以履行else語句，故輸入bc。是以本法式的輸入成果為
acbc
fork()函數示例三
#include "csapp.h"
int main()
{
int x=1;
if(fork()==0)
printf("printf1:x=%d\n",++x);
printf("printf2:x=%d\n",--x);
exit(0);
}
本法式再次演示子過程與父過程的差別。法式中，在子過程中，子過程同享數據x=1，而且fork()前往0，是以if語句被履行，輸入printf1:x=2,接著同享前面一部門代碼段，是以再輸入printf2:x=1；而關於父過程，fork()前往非零，是以不會履行if語句段，而履行前面的代碼，即輸入printf2:x=0.是以本法式輸入成果為（子過程與父過程次序不惟一）
printf2:x=0 printf1:x=2 printf2:x=1
fork()函數示例四
#include "csapp.h"
#define N 3
int main()
{
int status,i;
pid_t pid;
for(i=0;i<N;i++)
if((pid=fork())==0) //新建子過程
exit(100+i);
while((pid=waitpid(-1,&status,0))>0) { //假如子過程是正常終止的，就前往過程的過程號PID
if(WIFEXITED(status)) //前往加入狀況
printf("child %d terminated normally with exit status =%d\n",pid,WEXITSTATUS(status));
else
printf("child %d erminated abnormally\n",pid);
}
if(errno!=ECHILD)
printf("waitpid error\n");
exit(0);
}
本代碼重要是測試過程的終止，即waitpid案例法式。界說生成兩個過程，本例子是不依照特定次序往返收僵逝世子過程，本法式前往成果為
child 28693 terminated normally with exit status =100 child 28694 terminated normally with exit status =101 child 28695 terminated normally with exit status =102
fork()函數示例五
#include "csapp.h"
#define N 2
int main()
{
int status,i;
pid_t pid[N],retpid;
for(i=0;i<N;i++)
if((pid[i]=fork())==0)
exit(100+i);//加入並前往狀況碼
i=0;
while((retpid=waitpid(pid[i++],&status,0))>0) {
if(WIFEXITED(status))
printf("child %d terminated normally with exit status=%d\n",retpid,WEXITSTATUS(status));
else
printf("child %d terminated abnormally\n",retpid);
}
if(errno !=ECHILD)
printf("waitpid error!");
exit(0);
}
依照創立過程的次序往返收這些僵逝世過程，留意法式中的pid[i++]是順次的標記，本法式運轉成果為
child 29846 terminated normally with exit status=100 child 29847 terminated normally with exit status=101
fork()函數示例六
#include "csapp.h"
/*推想此法式會輸入甚麼樣的成果*/
int main()
{
int status;
pid_t pid;
printf("Hello\n");
pid=fork();
printf("%d\n",!pid);
if(pid!=0) {
if(waitpid(-1,&status,0)>0) {
if(WIFEXITED(status)!=0)
printf("%d\n",WEXITSTATUS(status));
}
}
printf("Bye\n");
exit(2);
}
起首父過程會輸入Hello，子過程新建勝利，在子過程中，pid為0，輸入1，而且子過程沒法履行if語句，然則子過程依然可以輸入Bye，而且正常加入並前往狀況碼為2。而在父過程中，pid為非零的負數，是以先輸入0，然後履行if語句，因為子過程曾經正常加入，故輸入狀況碼2，而且最初履行公共代碼塊，輸入Bye並正常加入。是以，總共輸入的成果以下所示：
Hello 0 1 Bye 2 Bye
固然，次序不惟一，還有一種能夠的成果是
Hello 1 Bye 0 2 Bye
