11_Concurrent_Programing

1.进程概念

在Linux中，进程是操作系统分配资源和调度运行的基本单位。

Linux中的进程有以下用处：

1. 提高CPU利用率：通过进程的并发执行，可以让多个程序同时利用计算机的资源，这样每个用户都可以感觉自己独占CPU，从而提高了CPU的效率。
2. 缩短响应时间：多进程环境下，用户可以启动多个任务而不互相干扰，系统能够快速响应用户的指令，从而缩短系统的响应时间。
3. 资源分配单位：进程是操作系统中最小的资源分配单位，它包含了程序执行过程中所需的所有资源，如地址空间、文件描述符等。
4. 提供抽象和管理：对于操作系统来说，进程是一种抽象，它允许操作系统通过管理进程来提高整个系统的资源利用率和效率。
5. 进程间通信：进程可以通过系统调用或信号来进行通信和同步，例如创建子进程、共享内存、管道、消息队列等方式。
6. 状态转换：进程的状态包括运行态、就绪态、阻塞态等，这些状态的转换由操作系统内核进行管理和调度，保证了系统的稳定运行。
7. 实现多任务：在Linux系统中，进程使得多任务成为可能。用户可以根据需要运行多个程序，而这些程序可以独立地执行，互不干扰。

进程在Linux系统中扮演着至关重要的角色，它们不仅提高了系统的资源利用率，还实现了多任务的并行处理，使得用户可以更加高效地进行工作。

以下是一些关于Linux进程的重要概念：

1. 进程定义：进程是一个程序的一次执行实例，它拥有一段可执行的程序代码、专用的系统堆栈空间、独立的存储空间以及一个进程控制块（PCB），在Linux中具体实现为task_struct结构。
2. 进程要素：每个进程都需要有一段程序供其运行，这是进程存在的前提。此外，进程还需要有自己的独立存储空间，用于存放变量和数据等。进程控制块则包含了进程的状态、优先级、资源使用情况等信息。
3. 多道程序设计：Linux是一个多道程序设计系统，这意味着系统中可以有多个彼此独立的进程同时运行。Linux允许进程在运行时创建额外的线程，每个进程都会有一个自己的程序计数器，用来记录下一个需要被执行的指令。
4. 守护进程：在Linux系统中，即使用户退出登录，仍然会有一些后台进程在运行，这些进程被称为守护进程（daemon）。它们通常负责系统服务或维护任务，如打印服务、系统日志服务等。
5. 进程管理：为了有效地管理和追踪所有运行着的进程，操作系统提供了一系列的工具和命令。用户可以查看所有运行中的进程、查看进程消耗的资源、定位个别进程并对其执行操作，如改变进程的优先级、杀死指定进程、限制进程可用的系统资源等。
6. 命令工具：Linux提供了许多命令来帮助用户高效地掌控进程管理，例如ps命令用于查看进程状态，top命令用于动态监控进程资源占用情况，kill命令用于终止指定进程等

进程内容

进程的内容通常包括以下几个主要部分：

1. 程序代码：这是定义进程行为的机器语言指令或高级语言语句的集合。
2. 数据：进程操作的数据，可能包括变量、常量、数据结构等，它们在进程的地址空间内被存储和管理。
3. 堆栈：用于维护函数调用和局部变量的存储区域。堆用于动态内存分配，栈用于执行函数调用和返回以及局部变量的存储。
4. 文件描述符：每个进程都有自己的文件描述符集合，它们是访问文件、管道和网络套接字等资源的引用。
5. 环境变量：进程运行时环境中的一些参数设置，比如PATH、HOME等，它们影响进程的行为和配置。
6. 信号处理程序：用于处理接收到的信号的程序，例如中断信号、终止信号等。
7. 寄存器值：记录了进程最后执行的指令位置等信息的硬件寄存器内容。
8. 进程控制块（PCB）：操作系统用来表示和管理进程的一个数据结构
   1. 进程标识PID
   2. 进程用户
   3. 进程状态、优先级
   4. 文件描述符（可储存1024个）
9. 用户ID和组ID：标识运行该进程的用户和用户组的信息，决定了进程的权限和访问控制。
10. 资源分配情况：包括内存分配、CPU时间片分配和其他资源的占用情况。
11. 上下文信息：包含进程的执行环境，比如CPU寄存器的内容、程序计数器、堆栈指针等，以便在调度时能够正确地恢复执行。
12. 线程信息：如果进程支持多线程，还会包含每个线程的相关信息和线程间的同步机制。
13. 这些内容共同组成了进程的全部信息，操作系统通过管理这些信息来调度和管理各个进程，确保系统资源的合理利用和系统的稳定运行。

进程类型

1. 交互进程：在shell下启动。以在前台运行，也可以在后台运行
2. 批处理进程：和在终端无关，被提交到一个作业队列中以便顺序执行
3. 守护进程：和终端无关，一直在后台运行

进程状态

1. 运行态：进程正在运行，或者准备运行
2. 可中断等待态：进程在等待一个事件的发生或某种系统资源
3. 不可中断等待态：同上
4. 停止态：进程被中止，收到信号后可继续运行
5. 死亡态：已终止的进程，但pcb没有被释放

2.进程常用命令

进程信息命令

1. ps 查看系统进程快照
2. top 查看进程动态信息
3. pstree 查看进程树，显示进程的层次结构

top 命令

1. 格式：top [options]
2. 功能：实时显示系统中各个进程的资源占用情况，包括CPU、内存等
3. 参数：
   • options(可选参数)
     • -d：设置刷新间隔时间。
     • -p：监控指定进程ID的进程。
     • -u：监控指定用户的进程。
     • -n：设置刷新次数。
     • -b：以批处理模式运行。
4. 示例：
   • shift+ > 后翻页
   • shift+ < 前翻页
   • top -p 1234监控指定进程ID为1234的进程
   • top -u root监控指定用户为root的进程

进程信息表

表头含义：

• F 进程标志，说明进程的权限，常见的标志有两个:

  • 1：进程可以被复制，但是不能被执行；
  • 4：进程使用超级用户权限；

• S 进程状态,常见的状态有以下几种：

  • -D：不可被唤醒的睡眠状态，通常用于 I/O 情况
  • -R：该进程正在运行
  • -S：该进程处于睡眠状态，可被唤醒
  • -T：停止状态，可能是在后台暂停或进程处于除错状态
  • -W：内存交互状态（从 2.6 内核开始无效）
  • -X：死掉的进程（应该不会出现）
  • -Z：僵尸进程。进程已经中止，但是部分程序还在内存当中
  • -<：高优先级（以下状态在 BSD 格式中出现）
  • -N：低优先级
  • -L：被锁入内存
  • -s：包含子进程
  • -l：多线程（小写 L）
  • -+：位于后台

• UID: 运行此进程的用户的 ID

• PID: 进程的 ID

• PPID: 父进程的 ID

• C: 该进程的 CPU 使用率，单位是百分比

• PRI: 进程的优先级，数值越小，该进程的优先级越高，越早被 CPU 执行

• NI: 进程的优先级，数值越小，该进程越早被执行；

• ADDR: 该进程在内存的哪个位置；

• SZ: 该进程占用多大内存；

• WCHAN: 该进程是否运行。"-"代表正在运行；

• TTY: 该进程由哪个终端产生；

• TIME: 该进程占用 CPU 的运算时间，注意不是系统时间；

• CMD: 产生此进程的命令名；

进程优先级命令

1. nice 启动进程时调整进程的优先级
2. renice 修改已经运行的进程的优先级

nice 命令

1. 格式：nice [options] [command]
2. 功能：启动进程时调整进程的优先级，使得CPU资源分配更加合理
3. 参数：
   • options（可选参数）
     • -n：设置进程的优先级，范围为-20（最高优先级）到19（最低优先级），默认值为0。
     • --adjust=N：调整当前进程的优先级，N的取值范围与-n相同。
   • command:命令，如ls、cd等
4. 示例：
   • nice command以默认优先级运行命令
   • nice -n -20 ls将进程优先级设置为最高（-20）

renice 命令

1. 格式：renice [options] [NI值] -p [ID]
2. 功能：修改已经运行的进程的优先级
3. 参数：
   • -n ：设置进程的优先级，范围为-20（最高优先级）到19（最低优先级），默认值为0。
   • -p：指定要修改优先级的进程ID。
   • -g：指定要修改优先级的进程组ID。
   • -u ：指定要修改优先级的用户ID。
4. 注意：
   • NI 范围是 -20~19。数值越大优先级越低
   • 普通用户调整 NI 值的范围是 0~19，而且只能调整自己的进程。
   • 普通用户只能调高 NI 值，而不能降低。如原本 NI 值为 0，则只能调整为大于 0。
   • 只有 root 用户才能设定进程 NI 值为负值，而且可以调整任何用户的进程。
5. 示例：
   • sudo renice -n -20 -p 1234将进程ID为1234的进程优先级设置为最高（-20）
   • sudo renice +5 -p 1234将进程ID为1234的进程优先级增加5

后台进程命令

1. jobs 查看后台进程
2. bg [进程号] 将挂起的进程在后台运行
3. fg [进程号] 把后台运行的进程放到前台运行
4. ctrl+z 把刚运行的程序转到后台运行
5. &: 在命令后面加上 & 符号可以将该命令放到后台执行

3.子进程

在Linux中，子进程是由父进程创建的进程。当一个进程被创建时，它会自动成为一个新进程的父进程，而新进程则成为子进程。子进程可以通过fork()系统调用来创建。

1. 创建子进程的意义：子进程常用于实现多任务并行处理，提高程序的执行效率。它们可以分担父进程的工作负载，或者执行不同的任务。
2. 父子进程区别：虽然子进程是父进程的一个拷贝，但它们有不同的内存地址空间。子进程获得与父进程相同的数据和属性的副本，但是有自己的数据段和堆栈段。

创建子进程

fork 函数

1. 原型：

   #include <unistd.h>
   pid_t fork(void);
   

2. 功能：创建一个新进程，新进程是当前进程的一个副本。新进程从父进程处继承了代码、数据、堆栈等资源，但是它们在不同的内存空间中运行。

3. 参数：无

4. 返回值：

   • 成功，创建新进程，则在父进程中返回新进程的进程ID（大于0），在子进程中返回0。
   • 失败，返回-1。

5. 示例1：在父进程中打印"pid = 进程号"，在子进程中打印"pid = 0"

   #include <stdio.h>
   #include <unistd.h>
   int main(int argc, const char *argv[])
   {
   	pid_t pid;
   	pid = fork();
   	printf("pid = %d\n",pid);
   	return 0;
   }
   

   示例2：fork的一般用法

   #include <stdio.h>
   #include <unistd.h>
   int main(int argc, const char *argv[])
   {
   	pid_t pid;
   	pid = fork();
   	printf("pid = %d\n",pid);
   
   	if(pid > 0)//父进程
   	{
   		printf("Father\n");
   	}
   	else if(pid == 0)//子进程
   	{
   		printf("Child\n");
   	}
   	else//出错
   	{
   		perror("fork\n");
   		return 0;
   	}
   	return 0;
   }
   

   示例3：使用for循环生成多个子进程

   #include <stdio.h>
   #include <unistd.h>
   int main(int argc, const char *argv[])
   {
   	pid_t pid;
   	int i;
   	for(i=0; i<3; i++)
   	{
   		pid = fork();
   		if(pid < 0)
   		{
   			perror("fork");
   			return 0;
   		}
   		else if(pid == 0)
   	 	{
   			printf("%d Child %d\n",i,pid);
   			sleep(5);
   		}
   		else if(pid > 0)
   		{
   			printf("%d Father%d\n",i,pid);
   			sleep(5);
   		}
   	}
   	return 0;
   }
   

   示例3分析：

   生成3个子进程3个孙进程1个曾孙进程

   • 子进程：2、3、5 （1 生的）
   • 孙进程：4、6、7 （2、3、5 生的）
   • 曾孙进程：8 （4、6、7 生的）

   

6. 注意：

   1. 子进程只执行fork之后的代码
   2. 父子进程执行顺序是操作系统决定的
   3. 子进程继承了父进程的内容
   4. 父子进程有独立的地址空间，互不影响
   5. 若父进程先结束，子进程成为孤儿进程，被init进程收养，子进程变成后台进程
   6. 若子进程先结束，父进程如果没有及时回收，子进程变成僵尸进程

结束进程

exit 函数

1. 原型：

   #include <unistd.h>
   void exit(int status);
   

2. 功能：终止当前进程，刷新(流)缓冲区并将退出状态码status传递给操作系统。这个状态码可以被其他进程或父进程获取，以了解子进程的结束状态

3. 参数：status是一个整数，表示进程的退出状态码

4. 返回值：无

_exit 函数

1. 原型：

   #include <unistd.h>
   void _exit(int status);
   

2. 功能：与exit函数类似，但_exit函数不会刷新(流)缓冲区，它直接终止进程，并将退出状态码传递给操作系统。

3. 参数：status是一个整数，表示进程的退出状态码

4. 返回值：无

​ return 和 exit 的区别：
​ main函数结束时会隐式地调用exit函数，普通函数return是返回上一级。

5. 示例：

   #include <stdio.h>
   #include <stdlib.h>
   int main(void) 
   {
       printf(“before exit”);
       exit(0);
       printf(“after exit”);
   }
   

   编译运行后只打印“before exit”

回收子进程

回收子进程的必要性：

1. 避免资源浪费：当一个子进程结束时，它能够释放自己用户区的资源，但无法释放内核空间的资源，如进程控制块（PCB）。如果父进程不回收这些资源，它们将一直占用内存，导致系统资源的浪费。
2. 获取退出信息：父进程通过回收子进程可以获取到子进程的退出状态，如退出码和执行时间等信息。这对于父进程监控子进程的行为和进行后续处理是非常重要的。
3. 防止僵尸进程：如果父进程没有及时回收子进程，那么子进程虽然已经结束，但其PCB仍然保留在系统中，这样的进程称为僵尸进程。僵尸进程不执行任何操作，但占用系统资源，如果大量僵尸进程存在，会影响系统性能。
4. 管理孤儿进程：如果子进程的父进程先于子进程结束，子进程将成为孤儿进程。为了避免孤儿进程无人管理，系统会让init进程（进程号为1的进程）收养它们。init进程会负责回收这些孤儿进程的资源。

回收子进程不仅是为了维护操作系统资源的有效性，也是为了保证程序能够正确获取子进程的执行结果，以及防止产生僵尸进程和妥善管理孤儿进程，从而保证系统的稳定性和程序的可靠性。

wait 函数

1. 原型：

   #include <unistd.h>
   pid_t wait(int *status);
   

2. 功能：挂起父进程的执行，直到一个子进程结束。一旦有子进程结束，wait()函数将返回该子进程的PID，并回收其资源。如果传入了status参数，则wait()函数还会将子进程的退出状态码写入到status指向的变量中。

3. 参数：status是一个整数指针，用于存储子进程的退出状态码。

4. 返回值：

   • 成功,返回已结束的子进程的PID；
   • 失败,返回-1，并设置errno为相应的错误码

5. 注：

   • 若子进程没有结束，父进程一直阻塞
   • 若有多个子进程，哪个先结束就先回收

6. 示例：

   #include <stdio.h>
   #include <sys/wait.h>
   #include <unistd.h>
   #include <stdlib.h>
                        
   int main(int argc, char** argv)
   {
      pid_t pid;
      pid_t rpid;
      pid = fork();
      int status;
      if(pid<0)//出错
      {
         perror("fork");
         return 0;
      }
      else if(pid == 0)//子进程
      {
          sleep(2);
          printf("child 2 \n");
          exit(2);
      }
      else if(pid >0)//父进程
      {
          rpid = wait(&status);
          printf("Get child status=%d\n",WEXITSTATUS(status));
      }
   }
   

waitpid 函数

1. 原型：

   #include <sys/types.h>
   #include <sys/wait.h>
   pid_t waitpid(pid_t pid, int *status, int options);
   

2. 功能：等待指定子进程的状态改变。当子进程结束时，该函数会返回子进程的进程ID，并将子进程的退出状态存储在status指向的变量中

3. 参数：

   • pid：指定要等待的子进程的进程ID。可以是以下值的组合：
     • -1：等待任意子进程。
     • 0：等待与调用进程属于同一进程组的任何子进程。
     • >0：等待指定的子进程。
   • status：指向一个整数变量的指针，用于存储子进程的退出状态。如果不关心退出状态，可以设置为NULL。
   • options：指定额外的选项，可以是以下值的组合：
     • WNOHANG：如果没有子进程状态改变，立即返回，不阻塞。
     • WUNTRACED：如果子进程进入暂停状态，也视为状态改变。

4. 返回值：

   • 成功时，返回已经停止的子进程的进程ID。
   • 如果没有任何子进程状态改变，根据options参数的设置，可能返回0或-1。
   • 失败时，返回-1，并设置errno。

5. 示例：

   #include <stdio.h>
   #include <sys/wait.h>
   #include <unistd.h>
   #include <stdlib.h>
                        
   int main(int argc, char** argv)
   {
      pid_t pid;
      pid_t rpid;
      pid = fork();
      int status;
      if(pid<0)//出错
      {
         perror("fork");
         return 0;
      }
      else if(pid == 0)//子进程
      {
          sleep(10);
          printf("child 2 \n");
          exit(2);
      }
      else if(pid >0)//父进程
      {
          waitpid(pid,&status,0);
          printf("Get child status=%d\n",WEXITSTATUS(status));
      }
   }
   

读取status参数

当使用wait()或waitpid()函数等待子进程结束时，可以通过传入的int *status指针来获取子进程的退出状态。这个状态包含两个主要部分：退出代码和信号编号（如果适用）。

通过以下宏来获取status的信息

• WIFEXITED(status) 判断子进程是否正常结束
• WEXITSTATUS(status) 获取子进程返回值
• WIFSIGNALED(status) 判断子进程是否被信号结束
• WTERMSIG(status) 获取结束子进程的信号类型

示例-创建进程链

创建一个进程链，父进程->子进程->孙进程->重孙进程->重重孙进程

#include <stdio.h>
#include <unistd.h>

int main(int argc, const char *argv[])
{
	pid_t pid;
	int i;

	for(i=0; i<5; i++)
	{
		pid=fork();
		if(pid < 0)
		{
			perror("fork");
			return 0;
		}
		if(pid > 0)
		{
			printf("father %d\n",i);
			break;
		}
		if(pid == 0)
		{
			printf("child %d\n",i);
		}
	}
	sleep(20);
	wait(0);
	return 0;
}

通过ps -elf | grep a.out 指令查看

4.exec函数族

exec函数族是一组用于在进程中启动另一个程序来替换当前进程的函数。

exec函数族主要用于在当前进程内部执行一个新的程序，而不会创建新的进程。

• 子进程调用exec函数，族父进程不受影响。
• 进程当前内容被指定的程序替换，但进程号不变

exec函数族中的一些主要成员：

1. execl：这是exec函数族中最简单的一个，它接受一个可执行文件路径和一个参数列表，列表以NULL结尾。这个函数将新程序的参数一一对应地传递给新程序。
2. execv：与execl类似，但是参数是通过一个指针数组传递的，而不是直接列出。
3. execlp 和 execvp：这两个函数会搜索PATH环境变量来找到可执行文件，而不需要提供完整的路径名。

execl 函数

1. 原型：

   #include <unistd.h>
   int execl(const char *path, const char *arg, ...);
   

2. 功能：execl函数用来执行一个文件，并将控制权转交给这个新程序。当调用成功时，原有进程的内容（代码段、数据段和堆栈等）将被新程序的内容取代，execl函数不会返回。

3. 参数：

   • path：要执行的程序的路径。
   • arg：传递给新程序的参数列表，最后一个参数需要是NULL，以标识参数列表的结束。

4. 返回值：

   • 如果调用成功，execl函数不会返回。
   • 如果调用失败（例如找不到指定的文件或没有足够的内存等），则返回-1，并设置errno来指示错误类型。

5. 注：execl函数后面的字母“l”代表的是“list”，意味着该函数通过参数列表的方式来传递参数

6. 示例:

   使用execl函数来执行ls命令

   #include <stdio.h>
   #include <unistd.h>
   int main(int argc, const char *argv[])
   {
   	if(execl("/bin/ls","ls","-a","-l","./",NULL)<0)
   	{
   		perror("execl");
   	}
   	return 0;
   }
   

   编译运行a.out 和 shell命令$ls -a -l 做对比

   

   运行效果一致

execlp 函数

1. 原型：

   #include <unistd.h>
   int execlp(const char *file, const char *arg, ...);
   

2. 功能：execlp函数用于在当前进程中执行指定的可执行文件，并用该新程序替换当前进程的映像。

3. 参数：

   • file：要执行的程序的文件名（或路径），不需要带扩展名，因为系统会自动根据文件名查找可执行文件。
   • arg：传递给新程序的参数列表，最后一个参数需要是NULL，以标识参数列表的结束。
   • ...：可选参数，可以传递多个，每个参数都会按顺序传递给新程序。

4. 返回值：

   • 如果调用成功，execlp函数不会返回。
   • 如果调用失败，则返回-1，并设置errno来指示错误类型。

execv 函数

1. 原型：

   #include <unistd.h>
   int execv(const char *path, char *const argv[]);
   

2. 功能：execv函数用来执行一个文件，并将控制权转交给这个新程序。与execl相似，当调用成功时，原有进程的内容（代码段、数据段和堆栈等）将被新程序的内容取代，execv函数不会返回。

3. 参数：

   • path：要执行的程序的路径。
   • argv：传递给新程序的参数数组，其中argv[0]通常是被执行文件的路径，数组的最后一个元素应该是NULL，以标识参数列表的结束。

4. 返回值：

   • 如果调用成功，函数不会返回。
   • 如果调用失败，则返回-1，并设置errno来指示错误类型。

execvp 函数

1. 原型：

   #include <unistd.h>
   int execvp(const char *file, char *const argv[]);
   

2. 功能：execvp函数用于在当前进程中执行指定的可执行文件，并用该新程序替换当前进程的映像。

3. 参数：

   • file：要执行的程序的文件名（或路径），不需要带扩展名，因为系统会自动根据文件名查找可执行文件。
   • argv：传递给新程序的参数数组，其中argv[0]通常是被执行文件的路径，数组的最后一个元素应该是NULL，以标识参数列表的结束。

4. 返回值：

   • 如果调用成功，execvp函数不会返回。
   • 如果调用失败，则返回-1，并设置errno来指示错误类型。

5. 示例：

   使用execv和execvp函数来执行ls命令

   #include <stdio.h>
   #include <unistd.h>
   int main(int argc, const char *argv[])
   {
   char *arg[] = {“ls”, “-a”, “-l”, “/etc”, NULL};
   if  (execv(“/bin/ls”, arg) < 0) {
   perror(“execv”);
   }  
   if  (execvp(“ls”, arg) < 0) {
   perror(“execvp”);
   }  
   	return 0;
   }
   

   运行效果同上

system 函数

1. 原型：

   #include <stdlib.h>
   int system(const char *command);
   

2. 功能：system函数用于在当前进程中创建一个子进程，并在子进程中执行一个shell命令。该函数会等待命令执行完成后返回。

3. 参数：

   • command：指向以空字符终止的字符串的指针，该字符串包含要在子进程中执行的命令。

4. 返回值：如果system函数成功执行了指定的命令，它将返回命令的退出状态。如果发生错误或命令无法执行，则返回-1。通常，返回值是shell的退出代码，可以通过WEXITSTATUS(status)宏来获取。

5. 注意：system函数的使用可能会带来安全风险，因为它允许执行任意的shell命令。因此，在安全性要求较高的环境中，应该避免使用system函数，或者至少对输入的命令进行严格的检查和限制。

6. 示例：

   #include <studio.h>
   #include <stdlib.h>
   int main()
   {
       system("ls -a -l ./");
   }
   

5.守护进程

概念：

守护进程又叫精灵进程（Daemon Process），它是一个生存期较长的进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。

特点：

始终在后台运行，独立于任何终端，周期性的执行某种任务或等待处理特定事件。

它是个特殊的孤儿进程，这种进程脱离终端，为什么要脱离终端呢？之所以脱离于终端是为了避免进程被任何终端所产生的信息所打断，其在执行过程中的信息也不在任何终端上显示。由于在 Linux 中，每一个系统与用户进行交流的界面称为终端，每一个从此终端开始运行的进程都会依附于这个终端，这个终端就称为这些进程的控制终端，当控制终端被关闭时，相应的进程都会自动关闭

举例：

http 服务的守护进程叫 httpd，mysql 服务的守护进程叫 mysqld。

相关名词：

• 进程组（Process Group）： 进程集合，每个进程组有一个组长（Leader），其进程 ID 就是该进程组 ID。
• 会话（Session）： 进程组集合，每个会话有一个组长，其进程 ID 就是该会话组 ID。
• 控制终端（Controlling Terminal）：每个会话可以有一个单独的控制终端，与控制终端连接的 Leader 就是控制进程（Controlling Process）。

创建守护进程

新用到的函数有：

1. setsid 于创建一个新的会话，并将当前进程设置为新会话的组长
2. getsid 获取当前进程所在会话的会话ID
3. getpid 获取当前进程的进程ID
4. getpgid 获取当前进程的进程组ID

setsid 函数

1. 原型：

   #include <unistd.h>
   pid_t setsid(void);
   

2. 功能：创建一个新的会话，并将当前进程设置为新会话的领导者。

3. 返回值：

   • 成功时返回新的会话ID
   • 失败时返回-1。

getsid 函数

1. 原型：

   #include <unistd.h>
   pid_t getsid(pid_t pid);
   

2. 功能：获取指定进程所在的会话ID。

3. 参数：pid - 要查询的进程ID。如果传入0，则返回当前进程所在的会话ID。

4. 返回值：

   • 成功时返回指定进程所在的会话ID
   • 失败时返回-1。

getpid 函数

• pid_t getpid(void);

• 获取进程id

getpgid 函数

• pid_t getpgid(pid_t pid);

• 获取进程组id

组长进程不能成为新会话首进程,新会话首进程必定会成为组长进程。

创建步骤

1.创建子进程，父进程退出

创建子进程然后结束父进程，子进程变成孤儿进程，被init进程收养，子进程在后台运行

if (fork() > 0)  
{
exit(0);
}

查看进程：$ps-ef|grepa.out结束进程：$kill -9 [进程号]

更简便的创建后台进程（不建议使用）

通过这条命令运行代码:$ nohub ./a.out &
进程进入后台运行

2.子进程创建新会话

if (setsid() < 0)  
{
	exit(-1);
}

子进程成为新的会话组长
子进程脱离原先的终端

4.更改当前工作目录

chdir(“/”);//更改当前工作目录到根目录

守护进程一直在后台运行，其工作目录不能被卸载
重新设定当前工作目录cwd

5.重设文件权限掩码

if (umask(0) < 0)  
{
	exit(-1);
}

文件权限掩码设置为0
只影响当前进程

6.关闭打开的文件描述符

close(0);
close(1);
close(2);

关闭所有从父进程继承的打开文件
已脱离终端，stdin / stdout / stderr无法再使用

7.守护进程创建完成

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
int main(int argc, const char *argv[])
{
  pid_t pid;
  pid = fork();
  if(pid<0)
  {
    perror("fork");
    return 0;
  }
    
  //1.结束父进程
  else if(pid>0)
  {
    exit(0);
  }
  printf("Deamon\n");
  printf("sid=%d,pid=%d,pgid=%d\n",
         getsid(getpid()),
         getpid(),
         getpgid(getpid()));
    
  //2.子进程创建新会话
  if(setsid()<0)
  {
    perror("setsid");
    exit(0);
  }
  printf("after sid=%d,pid=%d,pgid=%d\n",
         getsid(getpid()),
         getpid(),
         getpgid(getpid()));
    
  //3.更改当前工作目录到根目录
  chdir("/");
  
  //4.文件权限掩码设置为0
  if(umask(0)<0)
  {
    perror("unmask");
    exit(0);
  }
    
  //5.关闭打开的文件描述符
  close(0);
  close(1);
  close(2);
  printf("after close \n");  
  
  sleep(100);
  return 0；
}

GDB调试多进程程序

gcc编译.c程序时加入 -g 参数

gcc -g xxx.c
gdb a.out #进入调试

出现上图表示进入了gdb调试

gdb相关命令

• run 全速运行
• star 单步调试
• n 下一步
• set follow-fork-mode child/parent 设置GDB只跟踪 子/父 进程代码
• set setach-on-fork on/off 设置GDB跟踪调试单个进程或多个(默认为on)
  • on: 只调试父进程或子进程的其中一个，(根据follow-fork-mode来决定)，这是默认的模式
  • off：父子进程都在gdb的控制之下，其中一个进程正常调试(根据follow-fork-mode来决定),另一个进程会被设置为暂停状态。
• info inferiors 显示GDB调试的进程
• inferiors [进程序号] (1,2,3....)切换GDB调试的进程

6.线程创建

线程概念

线程和进程在使用资源、创建开销以及通信方式上存在显著差异。

首先，进程是系统资源分配的独立单位，每个进程拥有自己的地址空间，而线程则共享所隶属进程的地址空间。这意味着不同进程之间的资源如内存堆、栈是不能直接共享的，而同一进程内的多个线程可以直接访问这些共享资源。

其次，进程相较于线程有更大的创建和管理开销。因为进程有独立的地址空间，所以操作系统在创建或销毁进程时需要较大的系统资源开销。而线程作为调度的基本单位，其创建和上下文切换的开销要小得多，这也是为什么线程被称为轻量级进程的原因。

最后，由于线程间共享内存空间，它们之间的通信和数据共享更为简单直接。进程间则通常需要借助于进程间通信(IPC)机制，如管道、消息队列、共享内存等来完成数据交换。

线程特点

• 通常线程指的是共享相同地址空间的多个任务
• 使用多线程的好处
  • 大大提高了任务切换的效率
  • 避免了额外的TLB & cache的刷新

线程共享资源

一个进程中的多个线程共享以下资源：

1. 可执行的指令
2. 静态数据
3. 进程中打开的文件描述符
4. 当前工作目录
5. 用户ID
6. 用户组ID

线程私有资源

1. 线程ID (TID)
2. PC(程序计数器)和相关寄存器
3. 堆栈
4. 错误号 (errno)
5. 优先级
6. 执行状态和属性

线程创建

pthread_create 函数

1. 原型：

   #include <pthread.h>
   int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
   

2. 功能：创建一个新的线程，并使其开始执行指定的函数。

3. 参数：

   • pthread_t *thread：指向一个pthread_t类型的指针，用于存储新创建线程的标识符。
   • const pthread_attr_t *attr：指向一个pthread_attr_t类型的指针，用于设置线程的属性。如果传入NULL，则使用默认属性。
   • void *(*start_routine) (void *)：指向一个函数指针，该函数将在新线程中执行。函数的返回类型为void *，参数为void *。
   • void *arg：传递给start_routine函数的参数。

4. 返回值：

   • 成功时返回0
   • 失败时返回错误码。

5. 注意：创建线程后，若主进程运行结束，它创建的线程也会随之结束。

   所以，要在主进程预留一段时间等待线程结束，避免线程中断。

错误解决

使用pthread_create函数时出现的错误：

test_createP.c:(.text+0x4b)：对‘pthread_create’未定义的引用
collect2: error: ld returned 1 exit status

这个为链接错误，因为pthread_create函数的库为动态链接库
解决：在编译时加上 -lpthread
例：$gcc test.c -lpthread

线程结束

pthread_exit 函数

1. 原型：

   #include <pthread.h>
   void pthread_exit(void *retval);
   

2. 功能：结束当前线程，线程私有资源被释放，并将返回值传递给其他线程

3. 参数：void *retval：指向一个指针，用于存储线程的返回值。该值可以被其他线程通过pthread_join()函数获取。

查看线程

pthread_self 函数

1. 原型：

   #include <pthread.h>
   pthread_t pthread_self(void);
   

2. 功能：获取调用线程(自身所处线程)的标识符。

3. 返回值：返回调用线程的标识符，类型为pthread_t。

线程传参

线程间传参有两种方式，值传递和地址传递。

示例：arg1为地址传递，arg2为值传递

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

int * test_pth1(void *arg)
{
	printf("p1 tid = %lu\n",pthread_self());//线程ID
	printf("p1 pid = %d\n",getpid());//进程ID
	printf("p1 arg = %d\n",*(int *)arg);//传的参数
	pthread_exit(NULL);//退出线程
}
int * test_pth2(void *arg)
{
	printf("p2 tid = %lu\n",pthread_self());//线程ID
	printf("p2 pid = %d\n",getpid());//进程ID
	printf("p2 arg = %d\n",(int)arg);//传的参数
	pthread_exit(NULL);//退出线程
}
int main(int argc, const char *argv[])
{
	pthread_t tid;//线程ID
	int ret;
	int arg1,arg2;
	/*创建线程*/

	for(arg1=0; arg1<4; arg1++)
	{//地址传递
		ret = pthread_create(&tid,NULL,(void *)test_pth1,(void *)&arg1);
	}
sleep(1);
	for(arg2=0; arg2<4; arg2++)
	{//值传递
		ret = pthread_create(&tid,NULL,(void *)test_pth2,(void *)arg2);
	}
	printf("main tid%lu\n",tid);
	sleep(1);//等待线程结束
	return 0;
}

运行结果：

地址传递arg的值都为4，而值传递的arg值为创建线程时传入的值

地址传递的值会随着地址指向的数改变而改变，而线程创建的速度要比线程运行的速度要快，四个线程创建完后arg 的值为4，然后线程才开始运行，所以都打印出arg=4。

7.线程回收

两种方法回收线程

1. 使用pthread_join 函数
2. 使线程分离

1.pthread_join 函数

1. 原型：

   #include <pthread.h>
   int pthread_join(pthread_t thread, void **retval);
   

2. 功能：等待一个线程的结束

3. 参数：

   • thread：需要等待的线程ID。
   • retval：指向一个指针，用于存储被等待线程的返回值。如果不关心返回值，可以设置为NULL。

4. 返回值：

   • 成功时，返回0；
   • 失败时，返回一个非零的错误码。

5. 注意：pthread_join 是阻塞函数，如果回收的线程没有结束，则一直等待

6. 示例：

   创建了一个子线程，并在子线程中执行一个函数fun。主线程等待子线程结束后，打印子线程的返回值。

   #include <stdio.h>
   #include <pthread.h>
   #include <unistd.h>
   void *fun(void * arg)
   {
   	int i;
   	pthread_detach(pthread_self());
   	for(i=0; i<3; i++)
   	{
   		printf("child %d\n",i);
   		sleep(1);
   	}
   	pthread_exit("fun return");
   }
   int main(int argc, const char *argv[])
   {
   	int i = 0;
   	void *retf;
   	pthread_t tid;
   	pthread_create(&tid,NULL,fun,(void *)i);
   	pthread_join(tid,&retf);//等待线程结束
   	printf("%s\n",(char*)retf);
   	return 0;
   }
   

2.线程分离

线程分离是将线程设置为不被其他线程等待或回收的状态，从而在退出时自动释放资源。

• 如果不需要关心线程的返回值，或者不希望等待线程结束，可以将线程设置为分离状态。这样，线程在结束时会自动释放其所占用的资源，无需进行pthread_join操作，从而减少了程序的负担。
• 注意：一旦线程被分离，就不能再被其他线程回收，也就不能调用pthread_join。因此，在决定分离线程之前，应该仔细考虑线程的用途和生命周期。

两种方式使线程分离

1. 使用pthread_detach函数
2. 使用pthread_attr_init函数和pthread_attr_setdetachstate函数，设置线程属性为分离

pthread_detach 函数

1. 原型：

   #include <pthread.h>
   int pthread_detach(pthread_t thread);
   

2. 功能：将一个线程设置为分离状态，线程结束后（不会产生僵尸线程）

3. 参数：thread：需要设置为分离状态的线程ID。

4. 返回值：

   • 成功时，返回0；
   • 失败时，返回一个非零的错误码

5. 示例：

   #include <stdio.h>
   #include <pthread.h>
   #include <unistd.h>
   void *fun(void * arg)
   {
   	pthread_detach(pthread_self());//分离线程
   	printf("child %d\n",(int)arg);
   	pthread_exit(NULL);
   }
   int main(int argc, const char *argv[])
   {
   	int i;
   	pthread_t tid[10];
   	for(i=0; i<10; i++)//创建十个线程
   	{
   		pthread_create(&tid[i],NULL,fun,(void *)i);
   	}
   	sleep(10);//等待线程运行
   	return 0;
   }
   

设置线程属性为分离

pthread_attr_init函数

1. 原型：

   int pthread_attr_init(pthread_attr_t *attr);
   

2. 功能：初始化一个线程属性对象

3. 参数：attr：指向要初始化的线程属性对象的指针。

4. 返回值：

   • 成功时，返回0；
   • 失败时，返回一个非零的错误码。

pthread_attr_setdetachstate函数

1. 原型：

   #include <pthread.h>
   int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
   

2. 功能：设置线程属性对象的分离状态

3. 参数：

   • attr：指向要设置分离状态的线程属性对象的指针。

   • detachstate：指定线程的分离状态，可以是PTHREAD_CREATE_JOINABLE或PTHREAD_CREATE_DETACHED。

4. 返回值：

   • 成功时，返回0；
   • 失败时，返回一个非零的错误码。

示例：该线程在创建时就是分离的线程

pthread_attr_t attr;//定义线程属性变量
pthread_attr_init(&attr);//初始化该变量
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);//设置属性为分离
pthread_create(&tid,&attr,fun,NULL);//创建线程

可以通过top命令查看进程占用的内存空间大小，检验线程是否被回收

注意：分离后，进程结束，线程也会随之结束。

取消线程

pthread_cancel 函数

1. 原型：

   #include <pthread.h>
   int pthread_cancel(pthread_t thread);
   

2. 功能：取消一个线程的执行

3. 参数：thread：要取消执行的线程ID。

4. 返回值：

   • 成功时，返回0；
   • 失败时，返回一个非零的错误码。

5. 注意：线程的取消要有取消点才可以，不是说取消就取消，线程的取消点主要是阻塞的系统调用如sleep();

   若没有取消点，可手动设置一个取消点

pthread_testcancel 函数

1. 原型：

   #include <pthread.h>
   void pthread_testcancel(void);
   

2. 功能：在当前线程中创建一个取消点，这样如果该线程收到取消请求时，它可以在这个点上响应并执行相应的取消操作。

pthread_setcancelstate函数

1. 原型：

   #include <pthread.h>
   int pthread_setcancelstate(int state, int *oldstate);
   

2. 功能：设置线程的取消状态

3. 参数：

   • state：指定线程的取消状态，可以是PTHREAD_CANCEL_ENABLE或PTHREAD_CANCEL_DISABLE。

   • oldstate：指向一个整型变量的指针，用于保存线程原来的取消状态。

4. 返回值：

   • 成功时，返回0；
   • 失败时，返回一个非零的错误码。

pthread_setcanceltype函数

1. 原型：

   #include <pthread.h>
   int pthread_setcanceltype(int type, int *oldtype);
   

2. 功能：设置线程的取消类型

3. 参数：

   • type：指定线程的取消类型，可以是PTHREAD_CANCEL_DEFERRED（等到取消点才取消）、PTHREAD_CANCEL_ASYNCHRONOUS（目标线程会立即取消）

   • oldtype：指向一个整型变量的指针，用于保存线程原来的取消类型。

4. 返回值：

   • 成功时，返回0；
   • 失败时，返回一个非零的错误码。

示例：线程设置为可取消后，被取消，线程结束

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void *fun(void * arg)
{
	int i;
	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);//设置线程为不能取消
	for(i=0; i<10; i++)
	{
		printf("child %d\n",i);
		sleep(1);
	}
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);//设置线程为可以取消
	for(i=10; i<20; i++)
	{
		printf("child %d\n",i);
		sleep(1);
	}
	pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
	int i = 0;
	pthread_t tid;
	pthread_create(&tid,NULL,fun,(void *)i);
	sleep(5);//等待五秒	
	pthread_cancel(tid);//取消线程

	while(1)
	{
		sleep(1);
	}
	return 0;
}

线程的清理

当线程非正常终止，需要清理一些资源。

pthread_cleanup_push函数

1. 原型：

   #include <pthread.h>
   void pthread_cleanup_push(void (*routine)(void *), void *arg);
   

2. 功能：将一个清理函数压入线程的清理栈中

3. 参数：

   • routine：指向要压入清理栈中的清理函数的指针。

     • 被pthread_cancel取消掉。

     • 执行pthread_exit

     • 非0参数执行pthread_cleanup_pop()

   • arg：传递给清理函数的参数。

pthread_cleanup_pop函数

1. 原型：

   #include <pthread.h>
   void pthread_cleanup_pop(int execute);
   

2. 功能：用来解除之前通过pthread_cleanup_push注册的线程清理函数

3. 参数：execute：一个整数，表示是否执行清理函数。如果为非零值，则执行清理函数；如果为零，则不执行。

注意：

1. 必须成对使用，即使pthread_cleanup_pop不会被执行到也必须写上，否则编译错误。

2. pthread_cleanup_pop()被执行且参数为0，pthread_cleanup_push回调函数routine不会被执行.

3. pthread_cleanup_push 和pthread_cleanup_pop可以写多对，routine执行顺序正好相反

4. 线程内的 return 可以结束线程，也可以给pthread_join返回值，但不能触发pthread_cleanup_push里面的回调函数，所以我们结束线程尽量使用pthread_exit退出线程。

8.线程的同步和互斥

概念

1. 临界资源： 一次只允许一个任务(进程、线程)访问的共享资源

2. 临界区：访问临界资源的程序

3. 互斥机制：mutex互斥锁，任务访问临界资源前申请锁，访问完后释放锁

互斥锁

互斥锁创建

• 动态方式：

  • int pthread_mutex_init(pthread_mutex_t *restrict **mutex**,const pthread_mutexattr_t *restrict attr);

  • mutexattr：指定互斥锁属性，如果为NULL则使用缺省属性。

• 静态方式：

  • pthread_mutex_t **mutex** = PTHREAD_MUTEX_INITIALIZER;
  • mutex：锁的名称

锁的销毁

• int pthread_mutex_destroy(pthread_mutex_t *mutex)

• 在Linux中，互斥锁并不占用任何资源，因此LinuxThreads中的 pthread_mutex_destroy()除了检查锁状态以外（锁定状态则返回EBUSY）没有其他动作。

锁的使用

• #include <pthread.h>

• 申请锁：

  • int pthread_mutex_lock(pthread_mutex_t *mutex);
    • pthread_mutex_lock 如果无法获得锁，任务阻塞
  • int pthread_mutex_trylock(pthread_mutex_t *mutex);
    • pthread_mutex_trylock 如果无法获得锁，返回EBUSY而不是挂起等待
  • 执行完临界区要及时释放锁

• 释放锁：

  • int pthread_mutex_unlock(pthread_mutex_t *mutex);
  • 成功时返回0，失败时返回错误码
  • mutex 指向要初始化的互斥锁对象

示例

使用互斥锁，用两个线程写文件

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;//互斥锁创建锁
FILE *fp;
void *fun1(void *arg)
{
	int i;
	char c = 'A';
	pthread_detach(pthread_self());//分离线程
	printf("fun1...\n");
	i=0;
	pthread_mutex_lock(&mutex1);//互斥锁上锁
	while(i<26)
	{
		printf("%d\n",i);
		fputc(c+i,fp);
		usleep(1);
		i++;
	}
    fputc('\n',fp);
	fflush(fp);//刷新流	
	pthread_mutex_unlock(&mutex1);//互斥锁解锁
	pthread_exit("fun1 exit");
}
void *fun2(void *arg)
{
	int i;
	char c = 'a';
	pthread_detach(pthread_self());//分离线程
	printf("fun2...\n");
	i=0;
	pthread_mutex_lock(&mutex1);//互斥锁上锁
	while(i<26)
	{
		printf("%d\n",i);
		fputc(c+i,fp);
		usleep(1);
		i++;
	}
    fputc('\n',fp);
	fflush(fp);//刷新流	
	pthread_mutex_unlock(&mutex1);//互斥锁解锁
	pthread_exit("fun2 exit");
}
int main()
{
	pthread_t tid1,tid2;
	void *retv;
	int i;
	fp = fopen("1.txt","a+");//读写方式打开文件
	if(fp==NULL)
	{
		perror("fopen");
		return 0;
	}
	pthread_create(&tid1,NULL,fun1,NULL);
	pthread_create(&tid2,NULL,fun2,NULL);
    sleep(5);
    return 0;
}

man手册找不到

pthread_mutex_xxxxxxx （提示No manual entry for pthread_mutex_xxx）的解决方法：

输入命令：sudo apt-get install manpages-posix-dev

读写锁

​ 提高线程执行效率

特性

写者：写者使用写锁，如果当前没有读者，也没有其他写者，写者立即获得写锁；否则写者将等待，直到没有读者和写者。

读者：读者使用读锁，如果当前没有写者，读者立即获得读锁；否则读者等待，直到没有写者。

注意

同一时刻只有一个线程可以获得写锁，同一时刻可以有多个线程获得读锁。

读写锁出于写锁状态时，所有试图对读写锁加锁的线程，不管是读者试图加读锁，还是写者试图加写锁，都会被阻塞。

读写锁处于读锁状态时，有写者试图加写锁时，之后的其他线程的读锁请求会被阻塞，以避免写者长时间的不写锁

相关函数

#include <pthread.h>

• pthread_rwlock_init 初始化一个读写锁
  • int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr);
• pthread_rwlock_rdlock 读锁定读写锁
  • int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
• pthread_rwlock_tryrdlock 非阻塞读锁定
  • int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
• pthread_rwlock_wrlock 写锁定读写锁
  • int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
• pthread_rwlock_trywrlock 非阻塞写锁定
  • int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
• pthread_rwlock_unlock 解锁读写锁
  • int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
• pthread_rwlock_destroy 释放读写锁
  • int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

示例

创建两个读进程两个写进程，利用读写锁让它们互不干扰

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>

pthread_rwlock_t rwlock;//创建读写锁
FILE *fp;
void *fun1(void *arg)
{
	int i;
	char c = 'A';
	pthread_detach(pthread_self());//分离线程
	printf("fun1...\n");
	i=0;
	pthread_rwlock_wrlock(&rwlock);//写锁上锁
	while(i<26)
	{
		fputc(c+i,fp);
		usleep(1);
		i++;
	}
	fputc('\n',fp);
	fflush(fp);//刷新流	
	pthread_rwlock_unlock(&rwlock);//解锁
	pthread_exit("fun1 exit");
}
void *fun2(void *arg)
{
	int i;
	char c = 'a';
	pthread_detach(pthread_self());//分离线程
	printf("fun2...\n");
	i=0;
	pthread_rwlock_wrlock(&rwlock);//写锁上锁
	while(i<26)
	{
		fputc(c+i,fp);
		usleep(1);
		i++;
	}
	fputc('\n',fp);
	fflush(fp);//刷新流	
	pthread_rwlock_unlock(&rwlock);//解锁
	pthread_exit("fun2 exit");
}

void * fun3_read(void *arg)//读进程
{
	pthread_detach(pthread_self());//分离线程
	printf("fun3_read...\n");
	char buf[32]={0};
	while(1)
	{
		pthread_rwlock_rdlock(&rwlock);//读锁上锁
		while(fgets(buf,32,fp)!=NULL)
		{
			printf("%d,rd=%s\n",(int)arg,buf);
			usleep(1000);
		}
		pthread_rwlock_unlock(&rwlock);//读锁解锁
		sleep(1);
	}
	pthread_exit("fun3 exit");
}
void * fun4_read(void *arg)//读进程
{
	pthread_detach(pthread_self());//分离线程
	printf("fun4_read...\n");
	char buf[32]={0};
	while(1)
	{
		//rewind(fp);
		pthread_rwlock_rdlock(&rwlock);//读锁上锁
		while(fgets(buf,32,fp)!=NULL)
		{
			printf("%d,rd=%s\n",(int)arg,buf);
			usleep(1000);
		}
		pthread_rwlock_unlock(&rwlock);//读锁解锁
		sleep(1);
	}
	pthread_exit("fun4 exit");
}

int main()
{
	pthread_t tid1,tid2,tid3,tid4;
	void *retv;
	int i;
	fp = fopen("1.txt","a+");//读写方式打开文件
	if(fp==NULL)
	{
		perror("fopen");
		return 0;
	}
	pthread_rwlock_init(&rwlock,NULL);//初始化读写锁
	pthread_create(&tid1,NULL,fun1,NULL);
	pthread_create(&tid2,NULL,fun2,NULL);
	pthread_create(&tid3,NULL,fun3_read,(void *)3);
	pthread_create(&tid4,NULL,fun4_read,(void *)4);
 sleep(5);
	return 0;
}

死锁

死锁是指两个或多个进程在执行过程中，因争夺资源而造成的一种相互等待的永久阻塞状态。

死锁通常发生在多任务环境中，当两个或多个进程各自持有一部分资源，同时又互相等待对方释放另一部分资源时，就会产生死锁。这种现象在操作系统、数据库系统以及并发程序中都有可能出现。

产生死锁需要满足以下四个必要条件：

1. 互斥条件：资源至少有一个是不能被共享的，即一次只能由一个进程使用。
2. 占有和等待条件：一个进程至少已经持有一个资源，且正在请求额外的资源，而该资源可能被其他进程持有。
3. 非抢占条件：已经分配给进程的资源在未使用完之前不能被其他进程强行夺走，只能被占有它的进程释放。
4. 循环等待条件：存在一种进程资源的循环等待链，每个进程持有下一个进程所需的至少一个资源。

解决和避免死锁的方法包括：

1. 按照顺序加锁：对资源进行编号，并规定所有进程按照固定的顺序请求资源，以避免循环等待。
2. 设置获取锁的超时时间：限制进程等待资源的时间，若在指定时间内无法获取所需资源，则放弃已占有的资源或者回退操作。
3. 死锁检测与恢复：通过系统工具定期检测系统的资源分配情况，一旦发现死锁，采取措施解除死锁，如中断其中一个进程或者回收资源等

9.条件变量使用

条件变量是一种线程同步机制，允许一个或多个线程等待直到另一个线程发出信号通知条件已满足。

以下是条件变量的一些关键特性和应用：

1. 线程间通信：条件变量允许线程之间进行通信，当某个条件成立时，可以唤醒等待该条件的线程。
2. 与互斥锁结合：为了保护共享资源并防止竞态条件，条件变量通常与互斥锁一起使用。线程在等待条件时会释放互斥锁，允许其他线程访问共享资源；而当条件满足时，线程会重新获取互斥锁以继续执行。
3. 等待和通知机制：条件变量提供了一种机制，使得线程可以在条件不满足时等待，而在条件满足时被通知。这种机制提高了程序的效率，因为线程不需要循环检查条件是否满足。
4. 生产者消费者模型：条件变量常用于实现生产者消费者模型，其中生产者线程在生成数据时发出信号，消费者线程在数据可用时被唤醒进行处理。
5. 避免饥饿问题：通过合理地使用条件变量和互斥锁，可以避免线程饥饿问题，确保所有线程都有机会执行。
6. 接口和函数：在C语言中，条件变量的操作通常涉及pthread_cond_wait和pthread_cond_signal函数。pthread_cond_wait使线程等待某个条件，而pthread_cond_signal用于唤醒等待该条件的线程。

相关函数

pthread_cond_wait函数

1. 原型：

   #include <pthread.h>
   int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
   

2. 功能：等待条件变量，等待前互斥锁要上锁

3. 参数：

   • cond：指向要等待的条件变量的指针。
   • mutex：指向与条件变量关联的互斥锁的指针。在调用pthread_cond_wait之前，线程必须已经锁定了该互斥锁。

4. 返回值：

   • 成功时，返回0；
   • 失败时，返回一个非零错误码。

pthread_cond_timedwait函数

1. 原型：

   #include <pthread.h>
   int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abs_timeout);
   

2. 功能：等待条件变量一定时间，等待前互斥锁要上锁

3. 参数：

   • cond：指向要等待的条件变量的指针。
   • mutex：指向与条件变量关联的互斥锁的指针。在调用pthread_cond_timedwait之前，线程必须已经锁定了该互斥锁。
   • abs_timeout：指向一个timespec结构体，表示绝对超时时间。如果为NULL，则表示无限等待。

4. 返回值：

   • 成功时，返回0；
   • 失败时，返回一个非零错误码；
   • 超时时，返回ETIMEDOUT。

pthread_cond_signal函数

1. 原型：

   #include <pthread.h>
   int pthread_cond_signal(pthread_cond_t *cond);
   

2. 功能：当调用时，如果有线程正在等待该条件变量，那么其中一个将得到唤醒。如果没有线程在等待，信号会被保留，直到有线程开始等待。

3. 参数：cond：指向要发送信号的条件变量的指针。

4. 返回值：

   • 成功时，返回0；
   • 失败时，返回一个非零错误码。

5. 注意：在使用时需要注意避免惊群效应，即多个线程被同时唤醒但只有一个或少数几个能实际执行。这通常通过结合使用while循环和条件变量来避免。

pthread_cond_broadcast函数

1. 原型：

   #include <pthread.h>
   int pthread_cond_broadcast(pthread_cond_t *cond);
   

2. 功能：用于唤醒等待在指定条件变量上的所有线程。当有多个线程在等待同一个条件变量时，所有线程都会被唤醒。

3. 参数：cond：指向要发送信号的条件变量的指针。

4. 返回值：

   • 成功时，返回0；
   • 失败时，返回一个非零错误码。

使用步骤

生产者线程

1. 初始化

   //1.初始化条件变量
       /*静态初始化*/
       pthread_cond_t  cond = PTHREAD_COND_INITIALIZER;   
       /*动态初始化*/
       //pthread_cond_init(&cond);
   //2.初始化互斥锁变量
   	pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
   

2. pthread_mutex_lock(&lock1);//上锁
   

3. 生成资源

4. pthread_cond_signal(&hasProduct);//转为有资源状态，通知一个消费线程
   

5. pthread_cond_signal(&hasProduct);//转为有资源状态，通知一个消费线程
   //pthread_cond_broadcast(&hasProduct);//转为有资源状态，通知多个消费线程
   

6. pthread_mutex_unlock(&lock1);//解锁
   

消费者线程

1. pthread_mutex_lock(&lock1);//上锁
   

2. pthread_cond_wait(&hasProduct,&lock1);//等待有资源
   

3. 消费资源

4. pthread_mutex_unlock(&lock1);//解锁
   

[!NOTE]

1. pthread_cond_wait(&cond, &lock1);是在没有资源等待是是先unlock休眠，等资源到了，再lock。所以pthread_cond_wait 和 pthread_mutex_lock 必须配对使用。
2. 如果pthread_cond_signal 或者 pthread_cond_broadcast 早于 pthread_cond_wait ，则有可能会丢失信号。
3. pthead_cond_broadcast 信号会被多个线程收到，这叫线程的惊群效应。所以需要加上判断条件while循环。

示例

一个消费线程，一个生产线程

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
pthread_cond_t hasProduct=PTHREAD_COND_INITIALIZER;//条件变量
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;//互斥锁
struct product//产品结构体
{
	struct product *next;
	int num;
};
struct product *head = NULL;//头结点

void *fun1_make(void *arg)
{
	printf("fun1_make...\n");
	pthread_detach(pthread_self());//分离线程
	struct product *px;
	int i=1;
	while(1)
	{
		px = malloc(sizeof(struct product));
		px->num = i++;
		printf("product %d ok\n",px->num);
		pthread_mutex_lock(&lock1);//上锁
		/*生产资源*/
		px->next = head;
		head = px;

		pthread_cond_signal(&hasProduct);//转为有资源状态，通知一个消费线程
		//pthread_cond_broadcast(&hasProduct);//转为有资源状态，通知多个消费线程
		pthread_mutex_unlock(&lock1);//解锁
		sleep(1);
	}
}
void *fun2_buy(void *arg)
{
	printf("fun2_buy...\n");
	pthread_detach(pthread_self());
	struct product *px;
	while(1)
	{
		pthread_mutex_lock(&lock1);//上锁
		while(head == NULL)//防止惊群效应
		{
			pthread_cond_wait(&hasProduct,&lock1);//等待有资源
		}
		/*消费资源*/
		px = head;
		head = px->next;

		printf("arg=%d,buy over%d\n",(int)arg,px->num);
		free(px);
		pthread_mutex_unlock(&lock1);//解锁
	}
	pthread_exit(0);
}
int main(int argc, const char *argv[])
{
	pthread_t tid1,tid2,tid3,tid4;
	pthread_create(&tid1,NULL,fun1_make,NULL);
	sleep(1);
	pthread_create(&tid2,NULL,fun2_buy,(void *)2);
	//pthread_create(&tid3,NULL,fun2_buy,(void *)3);
	//pthread_create(&tid4,NULL,fun2_buy,(void *)4);
	
	while(1)
		sleep(1);
	return 0;
}

10.线程池

通俗的讲就是一个线程的池子，可以循环的完成任务的一组线程集合

必要性：

我们平时创建一个线程，完成某一个任务，等待线程的退出。但当需要创建大量的线程时，假设T1为创建线程时间，T2为在线程任务执行时间，T3为线程销毁时间，当 T1+T3 > T2，这时候就不划算了，使用线程池可以降低频繁创建和销毁线程所带来的开销，任务处理时间比较短的时候这个好处非常显著。

线程池的基本结构：

1. 任务队列，存储需要处理的任务，由工作线程来处理这些任务
2. 线程池工作线程，它是任务队列任务的消费者，等待新任务的信号

线程池实现步骤

1. 创建线程池的基本结构：

   typedef struct Task;  //任务队列链表
   typedef struct ThreadPool;  //线程池结构体
   

2. 线程池的初始化：

   pool_init()
   {
   	/*创建一个线程池结构*/
   	/*实现任务队列互斥锁和条件变量的初始化*/
   	/*创建n个工作线程*/
   }
   

3. 线程池添加任务：

   pool_add_task
   {
   	/*判断是否有空闲的工作线程*/
   	/*给任务队列添加一个节点*/
   	/*给工作线程发送信号newtask*/
   }
   

4. 实现工作线程：

   workThread
   {
       while(1)
       {
          /*等待newtask任务信号*/
          /*从任务队列中删除节点*/
          /*执行任务*/
       }
   }
   

5. 线程池的销毁

   pool_destory
   {
       /*删除任务队列链表所有节点，释放空间*/
       /*删除所有的互斥锁条件变量*/
       /*删除线程池，释放空间*/
   }
   

示例

20个任务，4个工作线程

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

#define POOL_NUM 4//线程池内工作线程数量
/*1.基本结构*/
typedef struct Task//任务链表结构体
{
	void *(*func)(void *arg);//任务（函数指针）
	void *arg;//函数参数
	struct Task *next;//下一个任务节点
}Task;

typedef struct ThreadPool//线程池结构体
{
	pthread_mutex_t taskLock;//任务互斥锁
	pthread_cond_t newTask;//条件变量

	pthread_t tid[POOL_NUM];//线程ID
	Task *queue_head;//任务链表头
	int busywork;//忙碌线程数
}ThreadPool;

ThreadPool *pool;//线程池变量

void *realwork(void *arg);
void pool_init();
void pool_add_task(int arg);
void *workThread(void *arg);
void pool_destory();

/*2.初始化*/
void pool_init()//线程池初始化
{
	int i;
	pool = malloc(sizeof(ThreadPool));//申请空间
	pthread_mutex_init(&pool->taskLock,NULL);//互斥锁初始化
	pthread_cond_init(&pool->newTask,NULL);//条件变量初始化
	pool->queue_head = NULL;//任务链表头节点
	pool->busywork=0;//忙碌线程数
    
	//创建线程
	for(i=0;i<POOL_NUM;i++)
	{
		pthread_create(&pool->tid[i],NULL,workThread,NULL);
	}
}

/*3.添加任务*/
void *realwork(void *arg)//“任务”
{
	printf("work%d\n",(int)arg);
}
void pool_add_task(int arg)//添加任务节点
{
	Task *newTask;//定义新任务节点

	pthread_mutex_lock(&pool->taskLock);//1上锁
    
    //等待任务链表空位
	while(pool->busywork>=POOL_NUM)//没有空闲线程
	{
		pthread_mutex_unlock(&pool->taskLock);//1解锁
		usleep(10000);//等待10ms
		pthread_mutex_lock(&pool->taskLock);//2上锁
	}
	pthread_mutex_unlock(&pool->taskLock);//2解锁
	
    //创建新任务节点
	newTask = malloc(sizeof(Task));//新任务节点申请空间
	newTask->func =  realwork;//新任务节点的任务
	newTask->arg = (void *)arg;//新任务节点的参数

    //将新节点从链表尾部加入
	pthread_mutex_lock(&pool->taskLock);//3上锁
	Task *member = pool->queue_head;
	if(member==NULL)//如果头节点为空
		pool->queue_head = newTask;
	else//如果头节点不为空
	{
		while(member->next!=NULL)//找到节点尾部
		{
			member=member->next;
		}
		member->next = newTask;//将新节点加入链表
	}
	pool->busywork++;
	pthread_cond_signal(&pool->newTask);//条件变量通知有资源
	pthread_mutex_unlock(&pool->taskLock);//3解锁
}

/*4.实现工作线程*/
void *workThread(void *arg)//工作线程函数
{
	while(1)
	{
		pthread_mutex_lock(&pool->taskLock);//上锁
		pthread_cond_wait(&pool->newTask,&pool->taskLock);//等待新任务
		//从链表头部取出任务节点
		Task *ptask = pool->queue_head;
		pool->queue_head = pool->queue_head->next;
		pthread_mutex_unlock(&pool->taskLock);//解锁

        //执行任务
		ptask->func((void *)ptask->arg);//通过节点取出任务函数，执行
		
        //任务结束
        pool->busywork--;
	}
}
/*5.线程池销毁*/
void pool_destory()
{
	Task *head;
	while(pool->queue_head!=NULL)
	{
		head = pool->queue_head;
		pool->queue_head = pool->queue_head->next;
		free(head);//释放节点空间
	}
	pthread_mutex_destroy(&pool->taskLock);//销毁互斥锁
	pthread_cond_destroy(&pool->newTask);//销毁条件变量
	free(pool);//释放线程池空间
}
int main()
{
	int i;
    
    //启动线程池
	pool_init();
	sleep(2);
    
    //添加任务
	for(i=1;i<=20;i++)
	{
		pool_add_task(i);
	}
	sleep(2);
	pool_destory();
}

GDB调试多线程程序

gcc编译.c程序时加入 -g 参数

gcc -g xxx.c
gdb a.out #进入调试

相关指令：

• (gdb) info thread
  • 显示线程
• (gdb) thread [id]
  • 切换线程
• (gdb) break location thread [id]
  • 为特定线程设置断点
• (gdb) b [行号]
  • 在行号处设置断点

• (gdb) b [行号] thread [id]

• (gdb) set scheduler-locking on/off
  • 设置线程锁
  • on：其他线程会暂停。可以单独调试一个线程
• (gdb) p threadName
  • 显示当前线程

11.进程间通信

（IPC，InterProcess Communication）进程和进程之间交换信息。

• 常用通信方式
  • 无名管道（pipe）
  • 有名管道 （fifo）
  • 信号（signal）
  • 共享内存(mmap)
  • 套接字（socket）
• 过时的IPC通信方式
  • System V IPC
  • 共享内存（share memory）
  • 消息队列（message queue）
  • 信号灯集（semaphore set）

无名管道

无名管道（也称为匿名管道）是UNIX和类UNIX系统下进程间通信的一种机制：

​ 数据读取完后自动删除不会留存

1. 半双工通信：数据只能在管道的一个方向上流动，具有固定的读端和写端。这意味着在一个时间点上，数据只能在一个方向上被传输，无法同时进行双向通信。
2. 亲缘关系进程间通信：无名管道通常用于具有亲缘关系的进程之间，如父子进程或兄弟进程之间的通信。一个进程创建管道后，可以通过fork()创建子进程，然后父子进程可以通过这个管道进行数据交换。
3. 特殊文件形式：无名管道可以看作是一种特殊的文件，对于它的读写可以使用普通的read、write等函数。但它并不属于任何文件系统，不支持如lseek()操作，且只存在于内存中。

读写特性

• 读管道：
  • 管道中有数据
    • read返回实际读到的字节数。
  • 管道中无数据：
    • 管道写端被全部关闭，read返回0 (好像读到文件结尾)
    • 写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu
• 写管道：
  • 管道读端全部被关闭
    • 进程异常终止(也可使用捕捉SIGPIPE信号，使进程不终止)
  • 管道读端没有全部关闭
    • 管道已满，write阻塞。（管道大小64K）
    • 管道未满，write将数据写入，并返回实际写入的字节数。

pipe函数

1. 原型：

   #include <unistd.h>
   int pipe(int pipefd[2]);
   

2. 功能：pipe函数创建一个管道，用于在两个文件描述符之间进行单向数据传输。一个文件描述符用于读操作，另一个用于写操作。

3. 参数：

   • int pipefd[2]: 一个包含两个整数的数组。

     • pipefd[0]是管道的读端，

     • pipefd[1]是管道的写端。

4. 返回值：

   • 成功时，返回0，并在pipefd中设置两个文件描述符。
   • 失败时，返回-1，并设置errno以指示错误类型。

5. 注意：

   • 只能用于亲缘关系的进程间通信（父子进程，兄弟进程）
   • 管道通信是单工的，一端读，一端写（程序实现设计好）。
   • 数据自己读不能自己写
   • 管道可以用于大于2个进程共享

示例

：一个父进程写，三个子进程读

#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main(){
	int pfd1[2];//文件描述符
	int re,i;
	char buf1[20]={0};
	char buf2[20]={0};
	pid_t pid;
    
    //创建无名管道
	re = pipe(pfd1);
	if(re<0)
	{
		perror("pipe");
		return 0;
	}
    
    //创建三个子进程
	for(i=0; i<3; i++)
	{
		pid = fork();//创建子进程
		if(pid<0)
		{
			perror("fork");
			return 0;
		}
		else if(pid == 0)//如果是子进程就退出循环
			break;
	}

	if(i==3)//父进程
	{
		//close(pfd1[0]);
		while(1)
		{
			strcpy(buf1,"hello world");
			write(pfd1[1],buf1,strlen(buf1));//写入管道

			sleep(1);
		}
	}
	else if(i==0)//子进程0
	{
		//close(pfd1[1]);        
		while(1)
		{
			re=read(pfd1[0],buf2,20);//读取管道数据
			if(re>0)
			{
				printf("0read pfd=%s\n",buf2);
			}    
		}
	}
	else if(i==1)//子进程1
	{
		//close(pfd1[1]);        
		while(1)
		{
			re=read(pfd1[0],buf2,20);//读取管道数据
			if(re>0)
			{
				printf("1read pfd=%s\n",buf2);
			}    
		}
	}
	else if(i==2)//子进程2
	{
		//close(pfd1[1]);        
		while(1)
		{
			re=read(pfd1[0],buf2,20);//读取管道数据
			if(re>0)
			{
				printf("2read pfd=%s\n",buf2);
			}    
		}
	}
}

有名管道（命名管道）

有名管道，也称为命名管道或FIFO（First In First Out），是一种特殊类型的管道，它允许不相关的进程通过文件系统进行通信。与无名管道相比，有名管道的一个显著特点是提供了一个路径名与之关联，从而可以在任意两个进程之间进行通信。

​ 数据读取完后自动删除不会留存

以下是有名管道的读写特性：

• 引用计数影响：当所有指向管道写端的文件描述符都关闭时（即写端引用计数为0），如果有进程尝试从读端读取数据，那么管道中剩余的数据被读取后，再次尝试读取会返回0，类似于读到文件末尾的情况。如果写端的引用计数大于0，即仍有文件描述符指向写端且没有写入数据，那么读端在读取完剩余数据后，再次读取会阻塞，直到有新的数据写入。
• 信号通知：当所有指向管道读端的文件描述符都关闭时（即读端引用计数为0），如果有进程试图向管道中写入数据，该进程会收到一个SIGPIPE信号，通常这会导致进程异常终止。
• 特殊文件形式：有名管道在文件系统中以特殊文件的形式存在，这意味着它可以通过路径名被访问，并且可以由任何有相应权限的进程使用。这与无名管道只能在亲缘关系的进程间通信不同。
• 半双工通信：尽管有名管道允许任意进程间通信，但它仍然是一种半双工通信方式，意味着数据只能在一个方向上流动，不能同时进行读写操作。

特点：

1. 有名管道可以使非亲缘的两个进程互相通信

2. 通过路径名来操作，在文件系统中可见，但内容存放在内存中

3. 文件IO来操作有名管道

4. 遵循先进先出规则

5. 不支持leek操作

6. 单工读写

mkfifo函数

1. 原型：

   #include <sys/types.h>
   #include <sys/stat.h>
   int mkfifo(const char *pathname, mode_t mode);
   

2. 功能：mkfifo函数创建一个命名管道（FIFO），该管道存在于文件系统中，可以用于不同进程之间的通信。

3. 参数：

   • const char *pathname: 管道的路径名。指定创建的命名管道的路径和文件名。

   • mode_t mode: 指定文件的权限位，如读、写、执行权限。通常使用宏定义，例如 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH 等。

4. 返回值：

open函数

1. 原型：

   #include <fcntl.h>
   #include <sys/types.h>
   #include <sys/stat.h>
   #include <unistd.h>
   int open(const char *pathname, int flags, ...);
   

2. 功能：open函数用于打开一个文件，如果成功，则返回一个文件描述符，该文件描述符可用于后续的读写操作。

3. 参数：

   • const char *pathname: 文件的路径名。指定要打开的文件路径。
   • int flags: 文件打开模式和标志位。常用的标志包括：
     • O_RDONLY: 只读模式
     • O_WRONLY: 只写模式
     • O_RDWR: 读写模式
     • O_CREAT: 如果文件不存在则创建文件
     • O_NONBLOCK（非阻塞）可以用|与其他模式连接，不加这个选项表示阻塞
     • O_EXCL: 与 O_CREAT 一起使用，如果文件已存在则返回错误
     • O_TRUNC: 如果文件存在且可写，则将其长度截断为0
     • O_APPEND: 每次写操作都会追加到文件的末尾
   • mode_t mode: 可选参数，仅在使用 O_CREAT 标志时需要。指定文件的权限位，例如 S_IRUSR（用户读权限）、S_IWUSR（用户写权限）、S_IRGRP（组读权限）等。

4. 返回值：

   • 成功时，返回文件描述符。
   • 失败时，返回-1，并设置errno以指示错误类型。

注意事项

1. 程序不能以O_RDWR(读写)模式打开FIFO文件进行读写操作，而其行为也未明确定义，因为如一个管道以读/写方式打开，进程可以读回自己的输出，同时我们通常使用FIFO只是为了单向的数据传递

2. 第二个参数中的选项O_NONBLOCK，选项O_NONBLOCK表示非阻塞，加上这个选项后，表示open调用是非阻塞的，如果没有这个选项，则表示open调用是阻塞的

3. **对于以只读方式（O_RDONLY）**打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_RDONLY），除非有一个进程以写方式打开同一个FIFO，否则它不会返回；如果open调用是非阻塞的的（即第二个参数为O_RDONLY | O_NONBLOCK），则即使没有其他进程以写方式打开同一个FIFO文件，open调用将成功并立即返回。

   对于以只写方式（O_WRONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_WRONLY），open调用将被阻塞，直到有一个进程以只读方式打开同一个FIFO文件为止；如果open调用是非阻塞的（即第二个参数为O_WRONLY | O_NONBLOCK），open总会立即返回，但如果没有其他进程以只读方式打开同一个FIFO文件，open调用将返回-1，并且FIFO也不会被打开。

4. 数据完整性,如果有多个进程写同一个管道，使用O_WRONLY方式打开管道，如果写入的数据长度小于等于PIPE_BUF（4K），那么或者写入全部字节，或者一个字节都不写入，系统就可以确保数据决不会交错在一起。

示例

：两个没有亲缘关系的进程通信

write.c

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
int main()
{
    int re;
    int fd;
    char buf[32];
    
    //创建管道文件
    re = mkfifo("/myfifo",0666);
    if(re<0)
    {
        perror("mkfifo");
        return 0;
    }
    
    //打开管道文件
    fd = open("/myfifo",O_WRONLY|O_NONBLOCK);//只写非阻塞方式打开
    if(fd<0)
    {
        perror("open");
        return 0;
    }
    printf("after open\n");
    
    //写入管道数据
    while(1)
    {
        fgets(buf,32,stdin);//读取键盘输入
        write(fd,buf,strlen(buf));
    }
}

read.c

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
int main()
{
    int re;
    int fd;
    char buf[32];
    fd = open("/myfifo",O_RDONLY);//只读阻塞方式打开管道文件
    if(fd<0)
    {
        perror("open");
        return 0;
    }
    printf("after open\n");
    
    //读取管道数据
    while(1)
    {     
        re=read(fd,buf,32);
        if(re>0)
            printf("read fifo=%s\n",buf);        
        else if(re==0)//
            exit(0);
    }
}

12.内存映射

使一个磁盘文件与内存中的一个缓冲区相映射，进程可以像访问普通内存一样对文件进行访问，不必再调用read,write，更加高效。

用到的函数

mmap函数

1. 原型：

   #include <sys/mman.h>
   void* mmap(void* start, size_t length, int prot, int flags, int fd, off_t offset);
   

2. 功能：创建共享内存映射

3. 参数：

   • addr：指定要映射的内存地址，一般设置为 NULL 让操作系统自动选择合适的内存地址。

   • length：必须>0。映射地址空间的字节数，它从被映射文件开头 offset 个字节开始算起。

   • prot：指定共享内存的访问权限。可取如下几个值的可选：

     • PROT_READ（可读）

     • PROT_WRITE（可写）

     • PROT_EXEC（可执行）

     • PROT_NONE（不可访问）

   • flags：由以下几个常值指定：

     1. MAP_SHARED（共享映射）

     2. MAP_PRIVATE（私有映射）

     3. MAP_FIXED（表示必须使用 start 参数作为开始地址，如果失败不进行修正）

     4. MAP_ANONYMOUS（匿名映射，用于血缘关系进程间通信）

        其中，MAP_SHARED , MAP_PRIVATE必选其一，而 MAP_FIXED 则不推荐使用。

   • fd：表示要映射的文件句柄。如果匿名映射写-1。

   • offset：表示映射文件的偏移量，一般设置为 0 表示从文件头部开始映射。

4. 返回值：

   • 成功返回创建的映射区首地址
   • 失败返回MAP_FAILED，设置errno值

lseek函数

1. 原型：

   #include <sys/types.h>
   #include <unistd.h>
   off_t lseek(int fd, off_t offset, int whence);
   

2. 功能：用于在文件中定位文件指针的位置

3. 参数：

   • fd：文件描述符，通常是通过open或fopen函数获得的。

   • offset：相对于whence的偏移量，以字节为单位。

   • whence：表示参考点的位置，可以是以下值之一：

     ：表示参考点的位置，可以是以下值之一：

     • SEEK_SET：文件开头
     • SEEK_CUR：文件当前位置
     • SEEK_END：文件结尾

4. 返回值：

   • 成功时，返回新的文件指针位置。
   • 失败时，返回-1，并设置errno

示例1

利用内存映射实现两个无亲缘关系的线程间的通信

write.c

#include <sys/mman.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc, const char *argv[])
{
	void *addr;
	int fd;
	fd = open("test",O_RDWR);
	if(fd<0)
	{
		perror("open");
		return 0;
	}

	//获取文件大小
	int fileSize = lseek(fd, 0, SEEK_END);
	lseek(fd, 0, SEEK_SET); // 将文件指针重置到文件开头

	//映射文件到内存
	addr = mmap(NULL,2000,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
	if(addr == MAP_FAILED)
	{
		perror("mmap");
		close(fd);
		return 0;
	}

	//写入文件
	int i = 0;
	printf("%d\n",fileSize);
	while(i < 2000)
	{
		printf("%d\n",i);
		memcpy(addr+i,"5",1);
		sleep(1);
		i++;
	}
	
	return 0;
}

read.c

#include <sys/mman.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc, const char *argv[])
{
	void *addr;
	int fd;
	fd = open("test",O_RDWR);
	if(fd<0)
	{
		perror("open");
		return 0;
	}

	//获取文件大小
	int fileSize = lseek(fd, 0, SEEK_END);
	lseek(fd, 0, SEEK_SET); // 将文件指针重置到文件开头

	//映射文件到内存
	addr = mmap(NULL,2000,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
	if(addr == MAP_FAILED)
	{
		perror("mmap");
		close(fd);
		return 0;
	}

	//读取
	int i = 0;
	printf("%d\n",fileSize);
	while(i < 2000)
	{
		printf("%s\n",(char *)addr);
		sleep(1);
	}
	
	return 0;
}

示例2匿名映射

利用内存映射匿名映射实现两个亲缘线程间的通信

#include <sys/mman.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/wait.h>

int main(){

    void *addr;
    
    //匿名映射
    addr = mmap(NULL,2048, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
    if(addr == MAP_FAILED)
    {
        perror("mmap");
        return 0;
    }

    //创建子进程
    pid_t pid;
    pid = fork();
    if(pid<0)
    {
        perror("fork");
        return 0;
    }

    //父进程
    else if(pid>0)
    {
        memcpy(addr,"1234567890",10);
        wait(NULL);//回收子进程
    }

    //子进程
    else 
    {
        sleep(1);
        printf("read father val=%s\n",(char *)addr);
    }
    munmap(addr,2048);//释放内存
}

注意事项

1. 创建映射区的过程中，隐含着一次对映射文件的读操作，将文件内容读取到映射区。

2. 当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)，如果不满足报非法参数（Invalid argument）错误。

   当MAP_PRIVATE时候，mmap中的权限是对内存的限制，只需要文件有读权限即可，操作只在内存有效，不会写到物理磁盘，且不能在进程间共享。

3. 映射区的释放与文件关闭无关，只要映射建立成功，文件可以立即关闭。

4. 用于映射的文件大小必须>0，当映射文件大小为0时，指定非0大小创建映射区，访问映射地址会报总线错误，指定0大小创建映射区，报非法参数错误（Invalid argument）

5. 文件偏移量必须为0或者4K的整数倍（不是会报非法参数Invalid argument错误）

6. 映射大小可以大于文件大小，但只能访问文件page的内存地址，否则报总线错误 ，超出映射的内存大小报段错误

   

7. 映射内存大小为4K的整数倍，若申请映射大小不为4K的整数倍，则会自动向上补齐。例如申请2k，实际可以操作的内存大小为4K。

System V共享内存

• 共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝
• 共享内存在内核空间创建，可被进程映射到用户空间访问，使用灵活
• 由于多个进程可同时访问共享内存，因此需要同步和互斥机制配合使用

共享内存使用步骤：

1. 生成key
2. 创建/打开共享内存
3. 映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问
4. 读写共享内存
5. 撤销共享内存映射
6. 删除共享内存对象

ftok函数

1. 原型：

   #include <sys/types.h>
   #include <sys/ipc.h>
   key_t **ftok**(const char *pathname, int proj_id);
   

2. 功能：生成一个唯一的与文件相关的键值（key），这个键值通常用于IPC（进程间通信）中，比如创建共享内存或信号量等。

3. 参数：

   • pathname：必须是存在的且可访问的文件路径。它可以是一个普通文件或者目录，但该路径下的某个文件需要具有相应的权限，以便其他进程可以通过该路径访问到相同的键值。
   • proj_id：是一个8位的整数（即范围在0到255之间）。它与文件的索引节点号结合生成最终的键值。

4. 返回值：

   • 如果函数执行成功，会返回一个key_t类型的键值
   • 如果执行失败，则返回-1

5. 注意：

   • 确保pathname指定的文件存在且可访问。

   • proj_id的值虽然作为int类型传递，但实际上只有8个比特被使用，因此其取值范围是0到255。

   • 生成的键值是由proj_id的后8个比特、文件所在设备的最后两位和文件的索引节点号的最后四位组成的

shmget函数

1. 原型：

   #include <sys/shm.h>
   int shmget(key_t key, size_t size, int shmflg);
   

2. 功能：获取或创建一个共享内存段，并返回一个共享内存标识符。

3. 参数：

   • key：共享内存的键值，可以是0（IPC_PRIVATE）以创建一个新的共享内存对象，或者是大于0的32位整数。如果shmflg中包含了IPC_CREAT标志，且提供的键值已经存在，则会返回现有的共享内存标识符。
   • size：指定需要共享的内存容量，以字节为单位。
   • shmflg：权限标志，与open函数的mode参数类似。如果希望在键值指定的共享内存不存在时创建它，可以与IPC_CREAT进行或操作。

4. 返回值：

   • 如果成功，shmget函数返回一个共享内存标识符，该标识符可以在后续的共享内存相关操作中使用，如shmat、shmdt和shmctl等。
   • 如果失败，返回-1。

5. 注意：

   • 不同进程可以通过shmget返回的共享内存标识符访问同一块共享内存。
   • 当写数据到共享内存时，需要注意同步问题，即在进程间访问共享内存时要加锁，以防止数据竞争。
   • 在使用共享内存时，应确保结构体中的缓冲区已经声明了足够的大小，而不是仅使用一个指针并在需要时通过malloc分配内存，因为这样分配的地址其他进程无法访问

ipcs 命令

1. 格式：ipcs [options]
2. 功能：ipcs 命令用于提供系统中进程间通信设施的信息，包括消息队列、共享内存段和信号量。
3. 参数：
   • -a 或 --all：显示所有类型的 IPC 资源信息。
   • -b 或 --broad：显示 IPC 资源的宽泛信息，包括最大允许的尺寸等。
   • -m 或 --shmems：仅显示共享内存段的信息。
   • -q 或 --queues：仅显示消息队列的信息。
   • -s 或 --semaphores：仅显示信号量的信息。
   • -i <id> 或 --identifier <id>：显示特定 IPC 资源 ID 的详细信息。
   • -l 或 --limits：显示系统限制信息。
   • -u 或 --summary：显示 IPC 资源的摘要信息。
   • -p 或 --pid：显示创建 IPC 资源的进程 ID。
   • -t 或 --time：显示最后操作 IPC 资源的时间。
   • -c 或 --creator：显示 IPC 资源的创建者信息。
   • -h 或 --human：以人类可读的格式显示大小。
   • -v 或 --version：显示 ipcs 命令的版本信息。
   • -V 或 --help：显示帮助信息。
4. 示例：
   • ipcs -a：显示所有类型的 IPC 资源信息。
   • ipcs -m：仅显示共享内存段的信息。
   • ipcs -q：仅显示消息队列的信息。
   • ipcs -s：仅显示信号量的信息。
   • ipcs -u：显示 IPC 资源的摘要信息。
   • ipcs -i 1234：显示 ID 为 1234 的 IPC 资源的详细信息。

shmat函数

1. 原型：

   #include <sys/shm.h>
   void *shmat(int shmid, const void *shmaddr, int shmflg);
   

2. 功能：将创建好的共享内存段连接到某个进程，并指定内存空间

3. 参数：

   • shmid：是通过shmget函数返回的共享内存标识符，它唯一标识了一个共享内存段。
   • shmaddr：是一个可选参数，用于指定共享内存映射到进程地址空间中的起始地址。如果传递NULL，则由系统自动选择一个地址进行映射。
   • shmflg：是一组标志位，用于控制共享内存的访问权限和其他属性。常见的标志包括SHM_RDONLY（只读访问）和SHM_WRONLY（只写访问）。

4. 返回值：

   • 成功，返回一个指向共享内存段在进程地址空间中映射的起始位置的指针。这个指针可以用于访问共享内存中的数据。
   • 失败，返回-1

shmdt函数

1. 原型：

   #include <sys/shm.h>
   int shmdt(const void *shmaddr);
   

2. 功能：从进程的地址空间中分离已经附加的共享内存段

3. 参数：shmaddr是一个指向共享内存段的指针，这个指针通常是通过shmat函数返回的。

4. 返回值：

   • 成功，shmdt函数返回0
   • 失败，返回 -1，并设置 errno 以指示错误原因。

shmctl函数

1. 原型：

   #include <sys/shm.h>
   int shmctl(int shmid, int cmd, struct shmid_ds *buf);
   

2. 功能：控制共享内存段，包括删除和修改权限等操作

3. 参数：

   • shmid：是通过shmget函数返回的共享内存标识符，唯一标识了一个共享内存段。
   • cmd：是控制命令，用于指定要执行的操作
     • IPC_STAT（获取共享内存的状态）
     • IPC_SET（设置共享内存的状态）
     • IPC_RMID（删除共享内存段）
   • buf：是一个指向shmid_ds结构体的指针，用于存储或接收共享内存的状态信息。在某些命令下，如IPC_STAT和IPC_SET，需要提供这个参数。

4. 返回值：

   • 成功，shmctl函数返回0；
   • 出错，返回 -1，并设置 errno 以指示错误原因

示例

创建和使用共享内存

write.c

#include <sys/types.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <sys/shm.h>
#include <string.h>

int main() {
    key_t key;  // 定义一个键值变量
    int shmid;  // 定义一个共享内存标识符变量
    char *buf;  // 定义一个指向共享内存的指针变量

    key = ftok("keytest", 100);  // 生成一个唯一的键值
    if (key < 0) 
    {
        perror("ftok");  
        return 0;
    }
    printf("key=%x\n", key);  // 打印生成的键值

    shmid = shmget(key, 512, IPC_CREAT | 0666);  //创建并获取共享内存段
    if (shmid < 0) 
    {
        perror("shmget");  
        return 0;
    }

    printf("shmid=%d\n", shmid);  // 打印共享内存标识符

    buf = shmat(shmid, NULL, 0);  // 将共享内存段附加到进程的地址空间中
    if (buf < 0) 
    {
        perror("shmat");  
        return 0;
    }

    strcpy(buf, "hello world");  // 将字符串"hello world"复制到共享内存中
}

read.c

#include <sys/types.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <sys/shm.h>
#include <string.h>

int main() {
    key_t key;  // 定义一个键值变量
    int shmid;  // 定义一个共享内存标识符变量
    char *buf;  // 定义一个指向共享内存的指针变量

    key = ftok("keytest", 100);  // 生成一个唯一的键值
    if (key < 0) 
    {
        perror("ftok");  
        return 0;
    }
    printf("key=%x\n", key);  // 打印生成的键值

    shmid = shmget(key, 512, 0666);  // 获取共享内存段
    if (shmid < 0) 
    {
        perror("shmget");  
        return 0;
    }

    printf("shmid=%d\n", shmid);  // 打印共享内存标识符

    buf = shmat(shmid, NULL, 0);  // 将共享内存段附加到进程的地址空间中
    if (buf < 0) 
    {
        perror("shmat");  
        return 0;
    }

    printf("read = %s\n",buf);
      
    if(shmdt(buf) == -1)//共享内存段从进程的地址空间中分离
        perror("shmdt");
    if(shmctl(shmid, IPC_RMID, NULL) == -1)//删除共享内存段
        perror("shmctl");
    
    return 0;
}

13.信号机制

概念：

信号机制是Unix、类Unix以及其他POSIX兼容的操作系统中的一种进程间通讯方式，它允许进程在发生特定事件时接收通知。

信号机制是操作系统中的一个重要概念，它提供了一种异步的通知机制，用于在进程之间传递消息。信号可以被看作是一种软中断，它们可以在任何时间被发送给一个进程，以通知该进程发生了某个特定的事件。信号的本质是在软件层次上模拟硬件中断的行为，但它完全由软件控制，因此被称为“软中断”。

信号的处理过程通常涉及以下几个步骤：

1. 信号的产生：当某个事件发生时，如用户按下Ctrl+C，或者程序访问了非法内存地址，操作系统会产生一个信号。
2. 信号的传递：产生的信号会被操作系统传递给目标进程。这个过程是异步的，意味着信号可以在任何时间点到达。
3. 信号的接收：进程通过注册信号处理函数来接收和处理信号。当信号到达时，如果进程已经为该信号注册了处理函数，操作系统会调用该函数。
4. 信号的处理：在信号处理函数中，进程可以决定如何处理信号。常见的处理方式包括忽略信号、采取默认行为（如终止进程）或执行自定义的操作。
5. 信号的屏蔽：进程可以选择暂时屏蔽某些信号，这样即使在信号产生时也不会被立即处理。这通常用于避免在某些关键操作中被信号中断。

在Linux系统中，信号机制是通过内核实现的。内核负责管理信号的发送和接收，并通过软中断的方式通知进程。进程可以通过系统调用来设置信号处理函数，从而定义对不同信号的响应方式。

常用信号