1. 进程操作

1.1 环境变量

1.1.1 关于环境变量 修改方式

image.png

1.1.2 环境变量加载的顺序

image.png

1.1.3 Linux下操作环境变量的函数

include
//这个全局变量是直接导出的，能够直接访问到所有的环境变量
extern char **environ;

void showallenviron()
{
for (char *ptr = environ; ptr != NULL; ++ptr)
puts(ptr);
}
//设置环境变量
void getenvirton()
{
// 设置环境变量 key:value
setenv(“TEST”,”12345678”,1);
// 获取环境变量内容
char test = getenv(“TEST”);
puts(test);
}
int main()
{
//showallenviron();
getenvirton();
return 0;
}

1.2 进程相关

1.2.1 基本信息

进程对象：PCB
结构体名：task_struct
内存布局：
image.png

1.2.2 命令

  1. ps命令 ps -aux

image.png
如果想要查看某个进程的信息
grep 进行一个过滤
image.png
上面这个命令，不是动态

  1. Linux版本的任务管理器-top命令

image.png

  1. 另外一个比较好用的进程查看工具

htop 默认是不安装的
apt-get install htop
image.png
如果想要结束一个进程
按 F9 选择9号 结束进程
也可以

  1. 结束进程

kill -9 进程的ID 也可以
killall 进程名

  1. 查看进程树

image.png

1.2.3 proc文件系统

image.png
我们去1645中查看
image.png
这些文件就是进程相关的信息
比如：
cat maps 查看进程的内存布局
image.png
cat cmdline查看命令行参数
image.png
cat status 查看进程的一些状态信息
image.png
还有一个进程信息的查看方式
cat stat 对于我们来说 可读性比较差 对于软件来说，可以按照一定的格式去读取他们
image.png

1.2.4 遍历进程的思路

我们可以遍历 proc目录下的 所有数字文件夹，然后就能够得到所有的进程ID，之后，进入ID文件夹，通过读取文件，就能够获取到进程的信息。
我们可以参考PS命令的实现方式：
下载源码：
image.png

  1. PS的源码：
  2. int main(int argc, char *argv[]){
  3.   arg_parse(argc, argv);
  4. #if 0
  5.   choose_dimensions();
  6. #endif
  7.   if(!old_h_option){
  8.     const char *head;
  9.     switch(ps_format){
  10.     default: /* can't happen */
  11.     case 0:        head = "  PID TTY         TIME CMD"; break;
  12.     case 'l':      head = "F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN    TTY       TIME CMD"; break;
  13.     case 'f':      head = "USER       PID  PPID  C STIME   TTY       TIME CMD"; break;
  14.     case 'j':      head = "  PID  PGID   SID TTY         TIME CMD"; break;
  15.     case 'u'|0x80: head = "USER       PID %CPU %MEM   VSZ  RSS   TTY   S START     TIME COMMAND"; break;
  16.     case 'v'|0x80: head = "  PID   TTY   S     TIME  MAJFL TRS DRS   RSS %MEM COMMAND"; break;
  17.     case 'j'|0x80: head = " PPID   PID  PGID   SID   TTY   TPGID S   UID     TIME COMMAND"; break;
  18.     case 'l'|0x80: head = "F   UID   PID  PPID PRI  NI   VSZ  RSS WCHAN  S   TTY       TIME COMMAND"; break;
  19.     }
  20.     printf("%s\n",head);
  21.   }
  22.   if(want_one_pid){
  23.     if(stat2proc(want_one_pid)) print_proc();
  24.     else exit(1);
  25.   }else{
  26.     struct dirent *ent;          /* dirent handle */
  27.     DIR *dir;
  28.     int ouruid;
  29.     int found_a_proc;
  30.     found_a_proc = 0;
  31.     ouruid = getuid();
  32.     dir = opendir("/proc");
  33.     while(( ent = readdir(dir) )){
  34.       if(*ent->d_name<'0' || *ent->d_name>'9') continue;
  35.       if(!stat2proc(atoi(ent->d_name))) continue;
  36.       if(want_one_command){
  37.         if(strcmp(want_one_command,P_cmd)) continue;
  38.       }else{
  39.         if(!select_notty && P_tty_num==NO_TTY_VALUE) continue;
  40.         if(!select_all && P_euid!=ouruid) continue;
  41.       }
  42.       found_a_proc++;
  43.       print_proc();
  44.     }
  45.   }
  46. }
  47. 另外一段
  48. static int stat2proc(int pid) {
  49.     char buf[800]; /* about 40 fields, 64-bit decimal is about 20 chars */
  50.     int num;
  51.     int fd;
  52.     char* tmp;
  53.     struct stat sb; /* stat() used to get EUID */
  54.     snprintf(buf, 32, "/proc/%d/stat", pid);
  55.     if ( (fd = open(buf, O_RDONLY, 0) ) == -1 ) return 0;
  56.     num = read(fd, buf, sizeof buf - 1);
  57.     fstat(fd, &sb);
  58.     P_euid = sb.st_uid;
  59.     close(fd);
  60.     if(num<80) return 0;
  61.     buf[num] = '\0';
  62.     tmp = strrchr(buf, ')');      /* split into "PID (cmd" and "<rest>" */
  63.     *tmp = '\0';                  /* replace trailing ')' with NUL */
  64.     /* parse these two strings separately, skipping the leading "(". */
  65.     memset(P_cmd, 0, sizeof P_cmd);          /* clear */
  66.     sscanf(buf, "%d (%15c", &P_pid, P_cmd);  /* comm[16] in kernel */
  67.     num = sscanf(tmp + 2,                    /* skip space after ')' too */
  68.        "%c "
  69.        "%d %d %d %d %d "
  70.        "%lu %lu %lu %lu %lu %lu %lu "
  71.        "%ld %ld %ld %ld %ld %ld "
  72.        "%lu %lu "
  73.        "%ld "
  74.        "%lu %lu %lu %lu %lu %lu "
  75.        "%u %u %u %u " /* no use for RT signals */
  76.        "%lu %lu %lu",
  77.        &P_state,
  78.        &P_ppid, &P_pgrp, &P_session, &P_tty_num, &P_tpgid,
  79.        &P_flags, &P_min_flt, &P_cmin_flt, &P_maj_flt, &P_cmaj_flt, &P_utime, &P_stime,
  80.        &P_cutime, &P_cstime, &P_priority, &P_nice, &P_timeout, &P_alarm,
  81.        &P_start_time, &P_vsize,
  82.        &P_rss,
  83.        &P_rss_rlim, &P_start_code, &P_end_code, &P_start_stack, &P_kstk_esp, &P_kstk_eip,
  84.        &P_signal, &P_blocked, &P_sigignore, &P_sigcatch,
  85.        &P_wchan, &P_nswap, &P_cnswap
  86.     );
  87. /*    fprintf(stderr, "stat2proc converted %d fields.\n",num); */
  88.     P_vsize /= 1024;
  89.     P_rss *= (PAGE_SIZE/1024);
  92.     memcpy(P_tty_text, "   ?   ", 8);
  93.     if (P_tty_num != NO_TTY_VALUE) {
  94.       int tty_maj = (P_tty_num>>8)&0xfff;
  95.       int tty_min = (P_tty_num&0xff) | ((P_tty_num>>12)&0xfff00);
  96.       snprintf(P_tty_text, sizeof P_tty_text, "%3d,%-3d", tty_maj, tty_min);
  97.     }
  100.     if(num < 30) return 0;
  101.     if(P_pid != pid) return 0;
  102.     return 1;
  103. }
  104. 遍历进程的实现
  105. #include <stdio.h>
  106. #include <dirent.h>
  107. #include <string.h>
  108. #include <sys/stat.h>
  109. #include <errno.h>
  110. // 显示进程名称
  111. void proc_show_name(int pid)
  112. {
  113.     // 打开文件
  114.     char path[266];
  115.     sprintf(path, "/proc/%d/status", pid);
  116.     FILE *fd = fopen(path, "r");
  117.     if (fd == NULL)
  118.     {
  119.         printf("无法打开文件 :%s\n", path);
  120.         return;
  121.     }
  122.     fscanf(fd, "Name: %s\n", path);
  123.     printf(" %s ", path);
  124.     // 关闭文件.
  125.     fclose(fd);
  126. }
  129. // 显示进程模块名称
  130. void proc_show_module(int pid)
  131. {
  132.     char path[266];
  133.     sprintf(path, "/proc/%d/maps", pid);
  134.     FILE *fd = fopen(path, "r");
  135.     if (fd == NULL)
  136.     {
  137.         printf("无法打开文件 :%s\n", path);
  138.     }
  139.         // %llx-%llx %4s %x %5s %d %s
  140.     unsigned long long base = 0, end = 0;
  141.     char pageatt[5];
  142.     int offset;
  143.     char time[6];
  144.     unsigned int inode;
  147.     while (
  148.         7 ==
  149.     fscanf(fd, "%llx-%llx %4s %x %5s %d %s",
  150.     &base, &end, pageatt, &offset, time, &inode, path))
  151.     {
  152.         if (offset == 0)
  153.         {
  154.             printf("\t%llx-%llx %4s %x %5s %d %s\n",
  155.              base, end, pageatt, offset, time, inode, path);
  156.         }
  157.     }
  160.     // 关闭文件.
  161.     fclose(fd);
  162.     return;
  163. }
  164. int main()
  165. {
  166.      //1.遍历/proc目录
  167.     struct DIR *pdir = opendir("/proc");
  168.     if (pdir == NULL)
  169.     {
  170.         printf("无法打开/proc目录\n");
  171.         return;
  172.     };
  173.     // 2.遍历目录下所有数字的目录
  174.     int pid;
  175.     char path[266] = {0};
  176.     char proc_name[100];
  177.     struct dirent *ent = NULL;
  178.     while (ent = readdir(pdir))
  179.     {
  180.         // 得到进程id,如果无法将字符串转换成数字,说明目录名不是进程id
  181.         if (1 != sscanf(ent->d_name, "%d", &pid))
  182.             continue;
  183.         // 进程信息(包括进程名)保存在status文件中中
  184.         proc_show_name(pid);
  185.         // 进程pid
  186.         printf("%6d \n", pid);
  187.         proc_show_module(pid);
  188.     }
  189.     // 3.关闭目录流cl
  190.     closedir(pdir);
  191. }

1.2.5 创建进程

  1. 使用fork创建一个子进程 ```cpp

    include

    include

    include

void CreateChild() { pid_t pid; const char *message = NULL; int n = 0; int i =0; pid = fork(); // 创建进程，子进程代码也是从这个地方开始执行 if(pid<0) { // pid大于0时表示当前处于父进程 perror(“fork failed\n”); return; } if (pid == 0){ //pid为0时时子进程 message = “this is the child\n”; n = 6; } else{ // pid是-1时错误 message = “this is the parent\n”; n=3; } for(i =0;i<n;i++) { printf(message); sleep(1); } return; } int main() { CreateChild(); return 0; }

  1. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/22743586/1638952286287-d90cb5ee-bb3b-4b1c-8e37-9570790bd5e0.png#clientId=ue2b19156-ddc7-4&from=paste&id=ub752cb82&margin=%5Bobject%20Object%5D&name=image.png&originHeight=330&originWidth=392&originalType=url&ratio=1&size=35876&status=done&style=none&taskId=u7b0fcc2a-5ac1-454a-adc7-f933b8fd3bf)
  2. <a name="D8mhq"></a>
  3. ### **1.2.6 创建进程并且能够 执行一个其他程序**
  4. ```cpp
  5. #include <unistd.h>
  6. #include <stdio.h>
  7. pid_t CreateProcess(char *name)
  8. {
  9.     pid_t pid;
  10.     pid = fork();   // 创建子进程
  11.     if(pid<0)
  12.     {
  13.         perror("fork failed\n");
  14.         return -1;
  15.     }
  16.     if (pid == 0)
  17.     {
  18.         execl(name,NULL); // 让子进程执行新程序
  19.     }else{
  20.         return pid;
  21.     }
  22.     return pid;
  23. }
  24. int main()
  25. {
  26.     CreateProcess("/home/pb/app");
  27.     return 0;
  28. }

1.2.7 关于子进程的等待

子进程是需要被父进程等待，才能够清理完全，

  1. #include <sys/types.h>
  2. #include <sys/wait.h>
  3. #include <unistd.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  7. int main(void)
  8. {
  9.   pid_t pid;
  10.   pid = fork();  // 创建子进程
  11. if (pid < 0) 
  12. {      // -1时错误
  13.   perror("fork failed"); 
  14.   exit(1);
  15. }
  16. if (pid == 0) {     // 子进程
  17.   int i;
  18.   for (i = 3; i > 0; i--) {
  19.   printf("This is the child\n");
  20.   sleep(1);
  21. }
  22. exit(3);
  23. } 
  24. else 
  25.     {            //父进程
  26.  int stat_val;
  27.  waitpid(pid, &stat_val, 0); // 等待指定的子进程结束,否则子进程会变成僵尸进程
  28.  if (WIFEXITED(stat_val))// 如果子进程正常结束则为非0值。
  29.  printf("Child exited with code %d\n", WEXITSTATUS(stat_val));
  30.  else if (WIFSIGNALED(stat_val)) // 进程是因为信号而结束则此宏值为真
  31.  printf("Child terminated abnormally, signal %d\n", WTERMSIG(stat_val));
  32. }
  33.   return 0;
  34. }

2. 线程

2.1 创建线程

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <pthread.h>
  7. // 线程回调函数
  8. void *thread_run(void *arg){
  9.     int n = (int)arg;
  10.     for(int i=0;i<10000;i++){
  11.        printf("child: %d out number%d \n",i,n);
  12.     }
  13.     // 释放线程资源
  14.     pthread_detach(pthread_self());
  15.     return NULL;
  16. }
  17. int main(){
  18.     //1.创建线程
  19.     pthread_t pthread;
  20.     pthread_create(&pthread,NULL,thread_run,100);
  21.     for(int i=0;i<10000;i++){
  22.         printf("main: %d \n",i);
  23.     }
  24.     //2. 等待线程结束
  25.     pthread_join(pthread,NULL);
  26.     return  0;
  27. }
  28. // 编译 gcc 01创建线程.c -g -lpthread -o app
  29. 总结：
  30. 子线程结束的时候，一定要调用pthread_detach 这个函数。
  31. 创建线程的地方，应该调用pthread_join去等待线程结束。

2.2 Linux上的线程同步问题的解决

  1. 问题：
  2. #include <stdio.h>
  3. #include <pthread.h>
  4. #include <unistd.h>
  5. // 全局变量（共享资源）
  6. int g_source = 0;
  7. // 线程1
  8. void *workthread1(void * param){
  9.     // 循环增加10000次
  10.     for (size_t i = 0; i < 10000; i++){
  11.         g_source += 1;
  12.     }
  13.     // 销毁线程
  14.     pthread_detach(pthread_self());
  15.     return NULL;
  16. }
  17. // 线程2
  18. void *workthread2(void * param){
  19.     // 循环增加10000次
  20.     for (size_t i = 0; i < 10000; i++){
  21.         g_source += 1;
  22.     }
  23.     // 销毁线程
  24.     pthread_detach(pthread_self());
  25.     return NULL;
  26. }
  27. int main(){
  28.     pthread_t threads[2]={};
  29.     // 创建两个线程
  30.     pthread_create(&threads[0],NULL,workthread1,0);
  31.     pthread_create(&threads[1],NULL,workthread2,0);
  32.     // 等待线程销毁
  33.     for (size_t i = 0; i < 2; i++)
  34.     {
  35.        pthread_join(threads[i],NULL);
  36.     }
  37.     // 显示全局变量的内容
  38.     printf("g_source = %d \n",g_source);
  39.     return 0;
  40. }
  41. 如何解决这个问题呢？？？
  42. 可以使用互斥锁
  43. #include <stdio.h>
  44. #include <pthread.h>
  45. #include <unistd.h>
  46. // 全局变量（共享资源）
  47. int g_source = 0;
  48. pthread_mutex_t counter_mutex=PTHREAD_MUTEX_INITIALIZER;
  51. // 线程1
  52. void *workthread1(void * param){
  53.     // 循环增加10000次
  54.     for (size_t i = 0; i < 100000; i++){
  55.         pthread_mutex_lock(&counter_mutex);     //获取锁
  56.         g_source += 1;
  57.         pthread_mutex_unlock(&counter_mutex);   //释放锁，其它线程才可以取得锁
  60.     }
  61.     // 销毁线程
  62.     pthread_detach(pthread_self());
  63.     return NULL;
  64. }
  65. // 线程2
  66. void *workthread2(void * param){
  67.     // 循环增加10000次
  68.     for (size_t i = 0; i < 100000; i++){
  69.         pthread_mutex_lock(&counter_mutex);     //获取锁
  70.         g_source += 1;
  71.         pthread_mutex_unlock(&counter_mutex);   //释放锁，其它线程才可以取得锁
  72.     }
  73.     // 销毁线程
  74.     pthread_detach(pthread_self());
  75.     return NULL;
  76. }
  77. int main(){
  78.     pthread_t threads[2]={};
  79.     // 创建两个线程
  80.     pthread_create(&threads[0],NULL,workthread1,0);
  81.     pthread_create(&threads[1],NULL,workthread2,0);
  82.     // 等待线程销毁
  83.     for (size_t i = 0; i < 2; i++)
  84.     {
  85.        pthread_join(threads[i],NULL);
  86.     }
  87.     // 显示全局变量的内容
  88.     printf("g_source = %d \n",g_source);
  89.     return 0;
  90. }
  91. 信号量解决问题
  92. #include <stdio.h>
  93. #include <pthread.h>
  94. #include <unistd.h>
  95. #include <semaphore.h>
  98. // 全局变量（共享资源）
  99. int g_source = 0;
  100. // 信号量
  101. sem_t g_semaphore;
  104. // 线程1
  105. void *workthread1(void * param){
  106.     // 循环增加10000次
  107.     for (size_t i = 0; i < 10000; i++){
  108.         sem_wait(&g_semaphore);                 //阻塞，直到获取信号，信号数-1
  109.         g_source += 1;                          //访问全局变量，不会被其它线程打断
  110.         sem_post(&g_semaphore);                 //释放一个信号数+1，让其它线程可以获取信号
  111.     }
  112.     // 销毁线程
  113.     pthread_detach(pthread_self());
  114.     return NULL;
  115. }
  116. // 线程2
  117. void *workthread2(void * param){
  118.     // 循环增加10000次
  119.     for (size_t i = 0; i < 10000; i++){
  120.         sem_wait(&g_semaphore);                 //阻塞，直到获取信号，信号数-1
  121.         g_source += 1;                          //访问全局变量，不会被其它线程打断
  122.         sem_post(&g_semaphore);                 //释放一个信号数+1，让其它线程可以获取信号
  123.     }
  124.     // 销毁线程
  125.     pthread_detach(pthread_self());
  126.     return NULL;
  127. }
  128. int main(){
  129.     pthread_t threads[2]={};
  130.     // 创建信号量
  131.     sem_init(
  132.         &g_semaphore, //信号量
  133.         0,            //0表示同一进程间线程同步
  134.         1);           //信号最大值
  135.     // 创建两个线程
  136.     pthread_create(&threads[0],NULL,workthread1,0);
  137.     pthread_create(&threads[1],NULL,workthread2,0);
  138.     // 等待线程销毁
  139.     for (size_t i = 0; i < 2; i++)
  140.     {
  141.        pthread_join(threads[i],NULL);
  142.     }
  143.     // 显示全局变量的内容
  144.     printf("g_source = %d \n",g_source);
  145.     // 销毁信号量
  146.     sem_destroy(&g_semaphore);
  147.     return 0;
  148. }
  149. 信号量，比较适合解决生产消费的问题。

3. 网络

image.png

image.png