营销型网站策划方案_门店库存管理软件_seo入门视频_seo关键词外包

1-1 fork函数初识

#include <unistd.h>
pid_t fork(void);
返回值：⾃进程中返回0，⽗进程返回⼦进程id，出错返回-1

• 分配新的内存块和内核数据结构给⼦进程

• 将⽗进程部分数据结构内容拷⻉⾄⼦进程

• 添加⼦进程到系统进程列表当中

• fork返回，开始调度器调度

int main( void )
{pid_t pid;printf("Before: pid is %d\n", getpid());if ( (pid=fork()) == -1 )perror("fork()"),exit(1);printf("After:pid is %d, fork return %d\n", getpid(), pid);sleep(1);return 0;
}
运⾏结果：
[root@localhost linux]# ./a.out
Before: pid is 43676
After:pid is 43676, fork return 43677
After:pid is 43677, fork return 0

写时拷⻉：是⼀种延时申请技术,可以提⾼整机内存的使⽤率

1-4 fork常规⽤法

1-5 fork调⽤失败的原因

2. 进程终⽌

2-1 进程退出场景

• 代码运⾏完毕，结果正确

• 代码运⾏完毕，结果不正确

• 代码异常终⽌

• 代码运⾏完毕，结果正确

return 0；

• 代码运⾏完毕，结果不正确

非0！（1，2，3……）不同的值代表着不同的出错原因

• 代码异常终⽌

gem@hcss-ecs-2ed8:~/linux_study/lesson8$ ./proc
0 -> Success
1 -> Operation not permitted
2 -> No such file or directory
3 -> No such process
4 -> Interrupted system call
5 -> Input/output error
6 -> No such device or address
7 -> Argument list too long
8 -> Exec format error
9 -> Bad file descriptor
10 -> No child processes
11 -> Resource temporarily unavailable
12 -> Cannot allocate memory
13 -> Permission denied
14 -> Bad address
15 -> Block device required
16 -> Device or resource busy
17 -> File exists
18 -> Invalid cross-device link
19 -> No such device
20 -> Not a directory
21 -> Is a directory
22 -> Invalid argument
23 -> Too many open files in system
24 -> Too many open files
25 -> Inappropriate ioctl for device
26 -> Text file busy
27 -> File too large
28 -> No space left on device
29 -> Illegal seek
30 -> Read-only file system
31 -> Too many links
32 -> Broken pipe
33 -> Numerical argument out of domain
34 -> Numerical result out of range
35 -> Resource deadlock avoided
36 -> File name too long
37 -> No locks available
38 -> Function not implemented
39 -> Directory not empty
40 -> Too many levels of symbolic links
41 -> Unknown error 41
42 -> No message of desired type
43 -> Identifier removed
44 -> Channel number out of range
45 -> Level 2 not synchronized
46 -> Level 3 halted
47 -> Level 3 reset
48 -> Link number out of range
49 -> Protocol driver not attached
50 -> No CSI structure available
51 -> Level 2 halted
52 -> Invalid exchange
53 -> Invalid request descriptor
54 -> Exchange full
55 -> No anode
56 -> Invalid request code
57 -> Invalid slot
58 -> Unknown error 58
59 -> Bad font file format
60 -> Device not a stream
61 -> No data available
62 -> Timer expired
63 -> Out of streams resources
64 -> Machine is not on the network
65 -> Package not installed
66 -> Object is remote
67 -> Link has been severed
68 -> Advertise error
69 -> Srmount error
70 -> Communication error on send
71 -> Protocol error
72 -> Multihop attempted
73 -> RFS specific error
74 -> Bad message
75 -> Value too large for defined data type
76 -> Name not unique on network
77 -> File descriptor in bad state
78 -> Remote address changed
79 -> Can not access a needed shared library
80 -> Accessing a corrupted shared library
81 -> .lib section in a.out corrupted
82 -> Attempting to link in too many shared libraries
83 -> Cannot exec a shared library directly
84 -> Invalid or incomplete multibyte or wide character
85 -> Interrupted system call should be restarted
86 -> Streams pipe error
87 -> Too many users
88 -> Socket operation on non-socket
89 -> Destination address required
90 -> Message too long
91 -> Protocol wrong type for socket
92 -> Protocol not available
93 -> Protocol not supported
94 -> Socket type not supported
95 -> Operation not supported
96 -> Protocol family not supported
97 -> Address family not supported by protocol
98 -> Address already in use
99 -> Cannot assign requested address
100 -> Network is down
101 -> Network is unreachable
102 -> Network dropped connection on reset
103 -> Software caused connection abort
104 -> Connection reset by peer
105 -> No buffer space available
106 -> Transport endpoint is already connected
107 -> Transport endpoint is not connected
108 -> Cannot send after transport endpoint shutdown
109 -> Too many references: cannot splice
110 -> Connection timed out
111 -> Connection refused
112 -> Host is down
113 -> No route to host
114 -> Operation already in progress
115 -> Operation now in progress
116 -> Stale file handle
117 -> Structure needs cleaning
118 -> Not a XENIX named type file
119 -> No XENIX semaphores available
120 -> Is a named type file
121 -> Remote I/O error
122 -> Disk quota exceeded
123 -> No medium found
124 -> Wrong medium type
125 -> Operation canceled
126 -> Required key not available
127 -> Key has expired
128 -> Key has been revoked
129 -> Key was rejected by service
130 -> Owner died
131 -> State not recoverable
132 -> Operation not possible due to RF-kill
133 -> Memory page has hardware error
134 -> Unknown error 134

这里可以看到关于返回值的打印个数最多是134个，一直到i=133结束

3. 进程等待

3-1 进程等待必要性

• 之前讲过，⼦进程退出，⽗进程如果不管不顾，就可能造成‘僵⼫进程’的问题，进⽽造成内存泄漏。

• 另外，进程⼀旦变成僵⼫状态，那就⼑枪不⼊，“杀⼈不眨眼”的kill -9 也⽆能为⼒，因为谁也没有办法杀死⼀个已经死去的进程。

• 最后，⽗进程派给⼦进程的任务完成的如何，我们需要知道。如，⼦进程运⾏完成，结果对还是不对，或者是否正常退出。

• ⽗进程通过进程等待的⽅式， 回收⼦进程资源 ，获取⼦进程退出信息

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int* status);
返回值：
成功返回被等待进程pid，失败返回-1。
参数：
输出型参数，获取⼦进程退出状态,不关⼼则可以设置成为NULL

pid_ t waitpid(pid_t pid, int *status, int options);
返回值：
当正常返回的时候waitpid返回收集到的⼦进程的进程ID；
如果设置了选项WNOHANG,⽽调⽤中waitpid发现没有已退出的⼦进程可收集,则返回0；
如果调⽤中出错,则返回-1,这时errno会被设置成相应的值以指⽰错误所在；
参数：
pid：
Pid=-1,等待任⼀个⼦进程。与wait等效。
Pid>0.等待其进程ID与pid相等的⼦进程。
status: 输出型参数
WIFEXITED(status): 若为正常终⽌⼦进程返回的状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS(status): 若WIFEXITED⾮零，提取⼦进程退出码。（查看进程的退出码）
options:默认为0，表⽰阻塞等待
WNOHANG: 若pid指定的⼦进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该⼦进程的ID。

• 如果⼦进程已经退出，调⽤wait/waitpid时，wait/waitpid会⽴即返回，并且释放资源，获得⼦

• 函数原型是pid_t waitpid(pid_t pid, int *status, int options);。它有三个参数。
• pid参数用于指定要等待的子进程的进程 ID。它有多种取值情况：
  • 当pid > 0时，表示等待进程 ID 为pid的特定子进程。
  • 当pid = 0时，表示等待与调用进程（父进程）同一个进程组中的任意一个子进程。
  • 当pid = - 1时，功能类似于wait函数，等待任意一个子进程结束。
  • 当pid < - 1时，表示等待进程组 ID 等于|pid|（pid的绝对值）的任意一个子进程。
• status参数的作用和wait函数中的status类似，用于获取子进程的退出状态。
• options参数是一个用于控制waitpid函数行为的选项，它可以使用一些位掩码常量（如WNOHANG）来实现非阻塞等待等特殊功能。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int main()
{pid_t pid;int status;pid = fork();if (pid == -1){perror("fork");return 1;}else if (pid == 0){// 子进程printf("子进程开始执行\n");// 模拟子进程执行一些耗时的任务，这里简单地睡眠一段时间sleep(5);printf("子进程结束执行\n");return 42;}else{// 父进程printf("父进程开始等待子进程，非阻塞方式\n");pid_t child_pid;do{child_pid = waitpid(pid, &status, WNOHANG);if (child_pid == 0){// 子进程还没有结束，父进程可以做其他事情printf("子进程还没有结束，父进程继续其他任务\n");sleep(1);}else if (child_pid == -1){perror("waitpid");return 1;}else{if (WIFEXITED(status)){int exit_status = WEXITSTATUS(status);printf("子进程 %d 正常退出，退出状态为 %d\n", child_pid, exit_status);}}} while (child_pid == 0);}return 0;
}

这就好比，我是张三，想叫李四出去吃饭，但是我一直再给他打电话催他好了没，这个打电话的过程就叫做非阻塞轮询，每次打电话都相当于一次函数调用；李四挂掉电话，就相当于一个返回值，告诉我他还没有好

 #include <stdio.h>3 #include <string.h>4 #include <errno.h>5 #include <stdlib.h>6 #include <unistd.h>7 #include <sys/types.h>8 #include <sys/wait.h>9  10  11  12 // 函数指针类型13 typedef void (*func_t)();14  15 #define NUM 516 func_t handlers[NUM+1];17  18 // 如下是任务19 void DownLoad()20 {21     printf("我是一个下载的任务...\n");22 }23 void Flush()24 {25     printf("我是一个刷新的任务...\n");26 }27 void Log()28 {29     printf("我是一个记录日志的任务...\n");30 }31  32  33  34 // 注册35  36 void registerHandler(func_t h[], func_t f)37 {38     int i = 0;39     for(; i < NUM; i++)40     {                                                                                                    41         if(h[i] == NULL)break;42     }if(i == NUM) return;                                                                                 44     h[i] = f;45     h[i+1] = NULL;46 }47  48 int main()49 {50     registerHandler(handlers, DownLoad);51     registerHandler(handlers, Flush);52     registerHandler(handlers, Log);53  54  55     pid_t id = fork();56     if(id == 0)57     {58         //子进程59         int cnt = 3;60         while(1)61         {62             sleep(3);63             printf("我是一个子进程, pid : %d, ppid : %d\n", getpid(), getppid());64             sleep(1);65             cnt--;66             //int *p = 0;67             //*p= 100;68            // int a = 10;69            // a /= 0;70         }71         exit(10);72     }73  74     // 父进程75     while(1)76     {77         int status = 0;78         pid_t rid = waitpid(id, &status, WNOHANG);79         if(rid > 0)80         {81             printf("wait success, rid: %d, exit code: %d, exit signal: %d\n", rid, (status>>8)&0xFF, stat82             break;}84         else if(rid == 0)85         {86             // 函数指针进行回调处理87             int i = 0;88             for(; handlers[i]; i++)89             {90                 handlers[i]();91             }92             printf("本轮调用结束，子进程没有退出\n");93             sleep(1);94         }95         else96         {97             printf("等待失败\n");98             break;99         }
100  
101     }return 0；}

加入vim一个小知识：将选定上级目录的一个文件夹的内容全都拷贝到当前文件夹内，注意这里有一个小点：

cp ../lesson9/* . -rf

其功能是将上级目录（.. 表示上级目录）下名为 lesson9 的目录中的所有内容（* 表示匹配所有文件和目录），复制到当前目录（. 表示当前目录）下，并且采用了强制覆盖（-r 表示递归复制，-f 表示强制，即使目标位置存在同名文件也直接覆盖）的方式。

4. 进程程序替换

4-1 替换原理

⽤fork创建⼦进程后执⾏的是和⽗进程相同的程序(但有可能执⾏不同的代码分⽀),⼦进程往往要调⽤⼀种exec函数以执⾏另⼀个程序。当进程调⽤⼀种exec函数时,该进程的⽤⼾空间代码和数据完全被新程序替换,从新程序的启动例程开始执⾏。调⽤exec并不创建新进程,所以调⽤exec前后该进程的id并未改变。

4-2 替换函数

其实有六种以exec开头的函数,统称exec函数:

#include <unistd.h>
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ...,char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);

可以看到当前程序execl，直接完成了系统调用，直接把系统的指令给跑起来，这一种现象就叫做进程的程序替换

在进程替换的过程中并没有创建新的进程，只是把当前进程的代码和数据用新的程序的代码和数据覆盖式的进行替换！

问题：为什么执行完替换后的代码后，我后面printf()函数怎么不继续打印了呢？

原因：一旦程序替换成功，就去执行新代码了，原始代码后半部分已经被覆盖式的替换带掉，不存在了

其中execl只有失败了才有返回值返回-1，在man手册内查询该函数的返回值：

可以看到只有失败了才会返回-1，否则成功了，已经被别的代码和数据给替换当前程序，在进行返回是没有意义的了

打印失败的返回值：

也就是说，在execl()函数后面直接根exit(1)函数即可，因为已经证明当前程序替换已经失败了：

认识进程程序替换的全部接口：

1.execl(const char *path,const char *arg,...)

其中*path，是路径+程序名，作用就是我需要去执行谁？

*arg，的写法就是命令行怎么写，arg就怎么写，如果是写多个命令，就相当于写多个字符串然后用一个list链表连接起来，这里面execl，这个l就是list的意思；

那么能不能既让程序进行程序替换，又能继续执行我后面执行的代码呢？

肯定是可以的，就比如创建一个子进程，然后进行程序替换，让父进程继续进行执行后续的代码：

所以这里可以看到父进程没有被子进程影响就是因为子进程发生了写时拷贝，进程之间具有独立性，这里看到子进程将父进程的 数据 和 代码 都进行来的拷贝，此时的父子进程将会完全独立！

由上可以看出exec*类型的接口就是加载器！代码运行有编译器，程序运行有加载器！

可以看到进过程序替换，也可以替换我们自己的程序！说明这样就仍然能够将python，php，shell这样的脚本语言给调用起来，也就是说只需要用C语言都可以将任何解释器给调用起来！

证明在进行execl程序替换的时候并没有创建新的进程，只是将数据和代码进行了替换，而进程都是同一个进程！

2.execlp(const char *file,const char *arg,...)

同样执行效果跟execl一样，只是多了一个p：PATH环境变量下去寻找指定路径

3.execv(const char* path,char *const argv[]);

其中v就代表vector，表示一个数组，就证明argv[]要传入一个指针数组，那么就要将我们输入的命令存入一个指针数组内，然后进行传参！

所以这里就对应着我们之前说到main(const char* argv[])函数内有*argv[]这个参数，所以之前写的关于*argv[]对应的传参就是将命令行参数存入这个指针数组内，然后再进行执行！

4.execvp(const char *file,char *const argv[]);

同上，*file就是可以直接再环境变量PATH内去寻找路径，*argv[]就是要将输入的指令按照指针存入这个指针数组内，然后进行传参！

5.execvpe(const char *file,char *const argv[],char *const envp[]);

用自己构造的环境变量env[]来直接直接覆盖掉原有的环境变量：

新增一个环境变量：putenv()

如果就只想要用execvpe来进行新增环境变量，而不是进行覆盖：

那么就要循环使用putevn，然后传入参数的时候evn换成**environ

所以这里新增环境变量有两种办法：

1.execvp 直接putenv

2.execvpe，要首先putenv()给子进程或者父进程的地址空间上;然后传入默认的环境变量首地址environ;

4-2-1 函数解释

• 这些函数如果调⽤成功则加载新的程序从启动代码开始执⾏,不再返回。

• 如果调⽤出错则返回-1

• 所以exec函数只有出错的返回值⽽没有成功的返回值。

4-2-2 命名理解

• l(list) : 表⽰参数采⽤列表

• v(vector) : 参数⽤数组

• p(path) : 有p⾃动搜索环境变量PATH

• e(env) : 表⽰⾃⼰维护环境变量

#include <unistd.h>
int main()
{
char *const argv[] = {"ps", "-ef", NULL};
char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
execl("/bin/ps", "ps", "-ef", NULL);
// 带p的，可以使⽤环境变量PATH，⽆需写全路径
execlp("ps", "ps", "-ef", NULL);
// 带e的，需要⾃⼰组装环境变量
execle("ps", "ps", "-ef", NULL, envp);
execv("/bin/ps", argv);
// 带p的，可以使⽤环境变量PATH，⽆需写全路径
execvp("ps", argv);
// 带e的，需要⾃⼰组装环境变量
execve("/bin/ps", argv, envp);
exit(0);
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <ctype.h>
using namespace std;
const int basesize = 1024;
const int argvnum = 64;
const int envnum = 64;
// 全局的命令⾏参数表
char* gargv[argvnum];
int gargc = 0;
// 全局的变量
int lastcode = 0;
// 我的系统的环境变量
char* genv[envnum];
// 全局的当前shell⼯作路径
char pwd[basesize];
char pwdenv[basesize];
// " "file.txt
#define TrimSpace(pos) do{\
while(isspace(*pos)){\
pos++;\
}\
}while(0)
string GetUserName()
{string name = getenv("USER");return name.empty() ? "None" : name;
}
string GetHostName()
{string hostname = getenv("HOSTNAME");return hostname.empty() ? "None" : hostname;
}
string GetPwd()
{if (nullptr == getcwd(pwd, sizeof(pwd))) return "None";snprintf(pwdenv, sizeof(pwdenv), "PWD=%s", pwd);putenv(pwdenv); // PWD=XXXreturn pwd;//string pwd = getenv("PWD");//return pwd.empty() ? "None" : pwd;
}
string LastDir()
{string curr = GetPwd();if (curr == "/" || curr == "None") return curr;// /home/whb/XXXsize_t pos = curr.rfind("/");if (pos == std::string::npos) return curr;return curr.substr(pos + 1);
}
string MakeCommandLine()
{// [whb@bite-alicloud myshell]$char command_line[basesize];snprintf(command_line, basesize, "[%s@%s %s]# ", \GetUserName().c_str(), GetHostName().c_str(), LastDir().c_str());return command_line;
}
void PrintCommandLine() // 1. 命令⾏提⽰符
{printf("%s", MakeCommandLine().c_str());fflush(stdout);
}
bool GetCommandLine(char command_buffer[], int size) // 2. 获取⽤⼾命令
{// 我们认为：我们要将⽤⼾输⼊的命令⾏，当做⼀个完整的字符串// "ls -a -l -n"char* result = fgets(command_buffer, size, stdin);if (!result){return false;}command_buffer[strlen(command_buffer) - 1] = 0;if (strlen(command_buffer) == 0) return false;return true;
}
void ParseCommandLine(char command_buffer[], int len) // 3. 分析命令
{(void)len;memset(gargv, 0, sizeof(gargv));gargc = 0;// "ls -a -l -n"const char* sep = " ";gargv[gargc++] = strtok(command_buffer, sep);// =是刻意写的while ((bool)(gargv[gargc++] = strtok(nullptr, sep)));gargc--;
}
void debug()
{printf("argc: %d\n", gargc);for (int i = 0; gargv[i]; i++){printf("argv[%d]: %s\n", i, gargv[i]);}
}
// 在shell中
// 有些命令，必须由⼦进程来执⾏
// 有些命令，不能由⼦进程执⾏，要由shell⾃⼰执⾏ --- 内建命令 built command
bool ExecuteCommand() // 4. 执⾏命令
{// 让⼦进程进⾏执⾏pid_t id = fork();if (id < 0) return false;if (id == 0){//⼦进程// 1. 执⾏命令execvpe(gargv[0], gargv, genv);// 2. 退出exit(1);}int status = 0;pid_t rid = waitpid(id, &status, 0);if (rid > 0){if (WIFEXITED(status)){lastcode = WEXITSTATUS(status);}else{lastcode = 100;}return true;}return false;
}
void AddEnv(const char* item)
{int index = 0;while (genv[index]){index++;}genv[index] = (char*)malloc(strlen(item) + 1);strncpy(genv[index], item, strlen(item) + 1);genv[++index] = nullptr;
}
// shell⾃⼰执⾏命令，本质是shell调⽤⾃⼰的函数
bool CheckAndExecBuiltCommand()
{if (strcmp(gargv[0], "cd") == 0){// 内建命令if (gargc == 2){chdir(gargv[1]);lastcode = 0;}else{lastcode = 1;}return true;}else if (strcmp(gargv[0], "export") == 0){// export也是内建命令if (gargc == 2){AddEnv(gargv[1]);lastcode = 0;}else{lastcode = 2;}return true;}else if (strcmp(gargv[0], "env") == 0){for (int i = 0; genv[i]; i++){printf("%s\n", genv[i]);}lastcode = 0;return true;}else if (strcmp(gargv[0], "echo") == 0){if (gargc == 2){// echo $?// echo $PATH// echo helloif (gargv[1][0] == '$'){if (gargv[1][1] == '?'){printf("%d\n", lastcode);lastcode = 0;}}else{printf("%s\n", gargv[1]);lastcode = 0;}}else{lastcode = 3;}return true;}return false;
}
// 作为⼀个shell，获取环境变量应该从系统的配置来
// 我们今天就直接从⽗shell中获取环境变量
void InitEnv()
{extern char** environ;int index = 0;while (environ[index]){genv[index] = (char*)malloc(strlen(environ[index]) + 1);strncpy(genv[index], environ[index], strlen(environ[index]) + 1);index++;}genv[index] = nullptr;
}
int main()
{InitEnv();char command_buffer[basesize];while (true){PrintCommandLine(); // 1. 命令⾏提⽰符// command_buffer -> outputif (!GetCommandLine(command_buffer, basesize)) // 2. 获取⽤⼾命令{continue;}//printf("%s\n", command_buffer);ParseCommandLine(command_buffer, strlen(command_buffer)); // 3. 分析命令if (CheckAndExecBuiltCommand()){continue;}ExecuteCommand(); // 4. 执⾏命令}return 0;
}

5-4 总结

在继续学习新知识前，我们来思考函数和进程之间的相似性exec/exit就像call/return ⼀个C程序有很多函数组成。⼀个函数可以调⽤另外⼀个函数，同时传递给它⼀些参数。被调⽤的函数执⾏⼀定的操作，然后返回⼀个值。每个函数都有他的局部变量，不同的函数通过call/return系统进⾏通信

这种通过参数和返回值在拥有私有数据的函数间通信的模式是结构化程序设计的基础。Linux⿎励将这种应⽤于程序之内的模式扩展到程序之间。如下图

⼀个C程序可以fork/exec另⼀个程序，并传给它⼀些参数。这个被调⽤的程序执⾏⼀定的操作，然后通过exit(n)来返回值。调⽤它的进程可以通过wait（&ret）来获取exit的返回值。

总结不易~本章节对我有很大收获，希望对你也是！！！~