Unix 环境高级编程：进程环境
原文链接：blog，转载注明来源即可。
本文代码：Github
本文结构
进程的环境
├── 执行程序：main 函数
├── 终止进程
├── 命令行参数
├── 进程的环境表
├── 进程的内存分布
├── 进程间的共享库
├── 内存分配
├── 环境变量
├── setjmp 与 longjmp 函数
└── getrlimit 与 setrlimit 函数执行程序：main 函数
定义
main() 是 C 程序的主函数，是程序执行的入口，Golang 与之类似，C99 标准对 main 的 2 种正确的定义：
// 无参数
int main(void) {
return 0;
}
// 有参数
int main(int argc, char *argv[]) {
return 0;
}
// main 还可有第三个参数 char *ecvp[]，用于存储运行环境的环境变量为提高程序的可移植性，避免使用下边对 main 定义的形式：
// 没有纳入 C 的标准，大部分编译器是不允许这么写的
void main() {
// ...
}参数值
// argc 即 argument counts，命令行中参数的个数，程序会在运行时自动统计
// argv 即 argument values，使用空格分隔，包含指向命令行参数值的指针。其中 argv[0] 为程序名
int main(int argc, char *argv[]) {
printf("argc: %d\n", argc);
int i;
for (i = 0; i < argc; i ) { // 循环输出全部的命令行参数
printf("argv[%d]: %s\n", i, argv[i]); // 命令行参数的类型全是字符串，只能使用 %s 输出
}
} 在程序中就能检查并获取运行参数了（a.out 相当于 Windows 上的 a.exe）：
返回值
return 0; 返回给操作系统程序的执行状态为 0，表示正常退出，返回其他值则认为程序发生了错误。如：
/* demo.c */
int main(void) {
return 233.7; // 返回值会被强制转换，截断为整型 233
}在 Unix 上使用 $? 来验证程序的退出状态：
说明：在 shell 中执行 cc demo.c && ./a.out 后 a.out 作为 shell 的子进程运行，在退出时将 0 返回给了 shell，故能使用 echo $? 查看其退出状态。
终止进程
终止的 8 种方式
5 种正常终止
main() 中 return
exit()
_exit() 或 _Exit()
多线程程序中，最后一个线程从其 main() 中 return
多线程程序中，从最后一个线程调用 pthread_exit()// ISOC 标准
#include<stdlib.h>
void exit(int status); // 正常结束当前正在执行的进程，将 status 返回给父进程，关闭进程打开的文件
// 关闭文件（I/O流）之前，会调用 fclose 将缓冲区数据写回该文件（I/O流 ）
void _Exit(int status); // 立刻结束当前进程，返回 status 并关闭打开的文件，但是不处理缓冲区
// POSIX 标准
#include<unistd.h>
void _exit(int status); // 同 _Exit() // 遵循的标准不一样，在不同的头文件中3 种异常终止
abort()
接到一个信号
多线程的程序中，最后一个线程对取消请求作出响应 // 多线程部分在第 12 章退出状态
状态范围
// 退出状态码为 0 ~ 255，超出后则返回 n % 256
int main(void) {
exit(257); // 返回 1
}状态不确定的三种情况
// 调用上边三个函数时无 status 参数
int main(void) {
exit(); // c99 标准的编译器会直接报错：too few arguments to function call
}
// main 没有声明返回值是整型
float main(void) {
exit(233); // 第一次返回 233，之后均返回 0
}
// main 执行了无返回值的 return 语句
void main(void) {
return ; // 第一次返回 176，之后均返回 0
}
atexit() 函数
#include<stdlib.h>
int atexit(void (*func) (void)); // 注册的函数参数和返回值均为 voidatexit() 注册的函数称为 exit handler，在进程退出时会被 exit() 自动调用后再清理缓冲区。有 2 个特点：
- 先注册的后调用：类似于 Golang 的 defer 语句，handlers 的调用也是栈顺序的
- 多次注册同一函数，依旧会被执行多次
特性：
int main(void) {
if (atexit(myExit2) != 0) {
err_sys("can't register myExit2"); // 终止函数先注册后调用
}
if (atexit(myExit1) != 0) {
err_sys("can't register myExit1");
}
if (atexit(myExit1) != 0) { // 终止程序登记一次就会被调用一次
err_sys("can't register myExit1");
}
printf("main is done\n");
return 0;
}
static void myExit1(void) {
printf("first exit handler\n");
}
static void myExit2(void) {
printf("second exit handler\n");
}运行：
限制：
书上说一个进程使用 atexit() 最多注册 32 个清理函数，但后来的操作系统有所差异，使用 sysconf 查看这个限制值：
#include <stdio.h>
#include <unistd.h>
int main(void) {
printf("%ld", sysconf(_SC_ATEXIT_MAX)); // 能注册 2147483647 个
}差距太大了，于是我在 macOS 上使用 for 循环验证了一下：
int main(void) {
for (int i = 0; i < 214748367; i ) {
if (atexit(myExit) != 0) { // 终止程序登记一次就会被调用一次
err_sys("can't register myExit1");
}
}
return 0;
}
static void myExit(void) {
printf("exit handler\n");
}程序能正确调用，只是内存占用会飙升233：
C 程序的启动与终止流程：
- 内核执行程序的唯一办法是调用
exec - 进程主动退出的唯一办法是调用
exit()、_Exit()、_exit()
命令行参数
在 main() 函数的参数值已讨论，不过遍历命令行参数的结束条件还有另一种方式：
// for (i = 0; i < argc; i ) { // 循环输出全部的命令行参数
for (i = 0; argv[i] != NULL; i ) { // POSIX 和 ISO C 标准都要求 argv[argc] 是空指针
printf("argv[%d]: %d\n", i, argv[i]);
}进程的环境表
ecvp 参数
环境参数是name=value 格式的字符串，能通过第三个参数 char *ecvp[] 接收到环境表：
int main(int argc, char *argv[], char *ecvp[]) {
for (int i = 0; ecvp[i] != NULL; i ) { // POSIX 要求 argv[argc] 是空指针
printf("ecvp[%d]: %s\n", i, argv[i]);
}
}输出的环境参数：
ecvp[8]: LANG=zh_CN.UTF-8
ecvp[9]: PWD=/Users/wuyin/C/apue
ecvp[10]: SHELL=/bin/zsh
...
ecvp[16]: HOME=/Users/wuyin
ecvp[18]: USER=wuyin
environ 全局变量
环境表与命令行参数表一样，也是字符指针数组，指针指向各环境参数。其地址存储在全局变量 environ 中：
#include <stdio.h>
#include <unistd.h>
extern char **environ; // 使用来自 unistd.h 的外部变量 environ，类型是指向指针的指针
int main(int argc, char *argv[], char *ecvp[]) {
char **env = environ;
while (*env != '\0') { // 环境参数字符串以 NULL 结尾
printf("%s\n", *env);
env ;
}
return 0;
}进程的内存分布
常驻内存：从进程开始到退出一直存在，使用常量地址访问。
静态区域
正文段
- 图中的 .text
- 内容：程序的机器指令
- 共享的：同时运行多个 shell，开始运行时都执行同一代码段；只读的：避免被篡改
只读数据段
- 图中 .rodata
- 内容：程序中不会修改的数据（常量），比如字符串
已初始化数据段
- 图中的 .data
- 内容：程序中初始化的数据，比如被赋初值的全局变量、静态变量
未初始化数据段
- 图中的 .bss
- 内容：程序中没有初始化的数据：比如仅声明，使用默认零值的变量
动态区域
堆
- 用于动态内存分配
- 一般由程序员手动分配 malloc 和 释放 free
栈
- 存放：临时数据：临时变量、调用函数时需要保存的数据等
- 函数在递归调用时，会新开一个栈来存储自身的变量集，所以变量互不影响
进程间的共享库
参考 阮一峰：编译器的工作过程
在 link 链接阶段，C 程序引用的库分为 2 种：
静态库 *.a、*.lib：外部函数库添加到可执行文件，体积大，但适用性更高
动态库（共享库）*.so、*.dll：外部函数库只在运行时动态引用，体积更小，但适用性更低
内存分配
动态内存分配函数
#include<stdlib.h> // 定义
// 分配 size 字节大小的内存区域
// 成功则返回内存地址，失败返回 NULL
void *malloc(size_t size);
// 分配 nobj 个长度为 size 字节的内存区域，并将每一个字节都初始化为 0
// 成功则返回内存地址，失败返回 NULL
void *calloc(size_t nobj, size_t size);
// 为 ptr 指向的空间分配新的 newsize 字节的内存
// ptr 必须指向动态分配的内存，即三个 *alloc() 函数的返回值
// ptr 为 NULL：realloc() 与 malloc() 相同
// newsize 为 0： ptr 指向的空间会被释放，返回 NULL，类似 free()
// 更大： 存储区域有足够的空间可扩充，则扩充后直接返回 ptr
// 存储区域没有足够的空间可扩充，复制 ptr 指向区域的数据到更大的内存空间
// 类似 Golang 中 slice 在 len 接近 cap 之后进行内存重新分配的操作
void *realloc(void *ptr, size_t newsize);注意
返回值类型
返回值都是 void * ，不是没有返回值或返回空指针，而是返回通用指针，指向的类型未知，类似于 Go 中的 interface{} 类型。在使用时，需要将返回的 void * 进行强制类型转换，方便存储数据
内存释放
必须使用 void free (void* ptr); 来手动释放分配的内存，如果忘记释放的内存累计过多，进程将可能出现内存泄漏
对一块内存只能释放一次，调用多次 free() 将出错
使用示例
#include <stdio.h>
#include <stdlib.h>
int main() {
int n = 2;
int *buf1 = (int *) malloc(n); // 强制将 void* 转换为 int*
if (buf1 == NULL) { // 检查是否分配成功
exit(1);
}
for (int i = 0; i < n; i )
printf("buf1[%d]: %d\n", i, buf1[i]); // malloc 分配的空间值的值是未知的
int *buf2 = (int *) calloc(n, sizeof(int)); // calloc 分配的空间有默认值 0
for (int i = 0; i < n; i )
printf("buf2[%d]: %d\n", i, buf2[i]);
free(buf1);
// free(buf);
// malloc: *** error for object 0x7fd9b4d000e0: pointer being freed was not allocated
// 没有 free(buf2) 则可能发生内存泄漏
return 0;
}运行：
环境变量
查询环境变量的值
#include<stdlib.h>
char *getenv(const char* name); // 环境变量 name 存在则返回值的指针，不存在则返回 NULL设置环境变量的值
#include<stdlib.h>
// str 是 name=value 格式的参数，用于新增或覆盖 name
// 执行成功返回 0，失败返回 -1
int putenv(char *str);
// 设置 name 环境变量的值为 value
// 若 rewrite == 0 则新增或不覆盖
// != 0 则新增或覆盖
int setenv(const char *name, const char *value, int rewrite);
// 删除 name 环境变量，不存在也不会报错
int unsetenv(const char *name);参考前边环境表的 environ 全局变量，操作环境参数时更推荐使用上边的函数。
setjmp 与 longjmp 函数
函数内跳转
在 C 中使用 goto 在函数内部（栈中）跳转，可往前也可往后跳。不过为了提高代码的可维护性，应尽量少使用。除非你明确要使用它来跳出深层次的循环，那也不错。
函数间跳转
在 C 中使用 setjmp() 与 longjmp() 在函数之间（栈之间）跳转：
#include<setjmp.h> // 定义
// env 参数的类型是 jmp_buf，用于标识当前进程状态的锚点
int setjmp(jmp_buf env);
// 使用与 setjmp 对应的 env 参数，调用时直接跳转到 env 处
// 一个 setjmp 可对应多个 longjmp，使用 val 标识是从哪里回退的
// val 即是 setjmp 的返回值
void longjmp(jmp_buf env, int val);示例
#include <stdio.h>
#include <setjmp.h>
#include <stdlib.h>
jmp_buf saved_state;
void myLongjmp();
int main(void) {
printf("设置 setjmp 的锚点\n");
int ret_code = setjmp(saved_state);
if (ret_code == 1) {
printf("结束序号为 1 的跳转\n");
return 0;
}
int *flag = (int *) calloc(1, sizeof(int));
myLongjmp(); // 直接跳转到第 11 行
}
void myLongjmp() {
printf("准备开始序号为 1 的跳转\n");
longjmp(saved_state, 1);
}效果：
内存泄漏
使用 Valgrind 做内存泄漏检测，结果显示有 4 字节的内存 lost，即是 16 行分配的内存没有释放：
在 setjmp() 和 longjmp() 之间分配的内存，在跳转后直接就废弃了，可能会因此发生内存溢出。
和 goto 一样，除非你知道自己在做什么，否则应尽量避免使用。
getrlimit 与 setrlimit 函数
系统对进程能调用的资源有限制，可使用 getrlimit() 来查看、setrlimit() 来修改
函数原型
#include<sys/resource.h> // 定义
// resource 是标识资源类型的常量
// rlimit 的定义
struct rlimit {
rlim_t rlim_cur; // current (soft) limit // 当前软链接的限制值
rlim_t rlim_max; // maximum value for rlim_cur // 硬链接的限制值
};
// 修改成功返回 0，失败返回非 0
int getrlimit(int resource, struct rlimit *rlptr);
int setrlimit(int resource, struct rlimit *rlptr);可修改的资源值
| 参数值 | 参数说明 |
|---|---|
| RLIMIT_AS | 进程可使用的最大存储 |
| RLIMIT_NOFILE | 进程可打开的最大文件数 |
| RLIMIT_STACK | 进程的栈的最大长度 |
| … | … |
更多请参考：手册
总结
开始学习 APUE 就卡在了第三章，于是从第七章熟悉的 main() 开始学起，发现 C 和 Golang 真的有千丝万缕的联系，比如 atexit() 与 defer func(){}，另外还有进程相关的内存分布、内存分配都值得深入学习，后边依旧在本篇笔记中补充。
计划下周 4.27 前更新第八章笔记 :)
到此这篇关于“Unix 环境高级编程：进程环境”的文章就介绍到这了,更多文章或继续浏览下面的相关文章，希望大家以后多多支持JQ教程网！您可能感兴趣的文章：
一文了解Python虚拟环境
java环境变量设置步骤介绍
细数PHP中16个高危函数
PHP中16个高危函数
如何设置PHP的环境变量步骤（windows系统）
go 语言环境搭建
关于java 的 Classpath全解<java入门之二>
python如何配置虚拟环境
Java开发环境的过去、现在和将来
gitbash PHP 执行输出中文乱编解决方式