电子发烧友App
什么是进程
1、进程和线程的区别
进程是指正在运行的程序，它拥有独立的内存空间和系统资源，不同进程之间的数据不共享。进程是资源分配的基本单位。
线程是进程内的执行单元，它与同一进程内的其他线程共享进程的内存空间和系统资源。线程是调度的基本单位。
2、进程的创建和销毁
在Linux中启动一个进程有多种方法：
（1）通过system函数启动进程。（使用简单，效率较低）
?
#include? /** ?*?@brief?执行系统命令调用命令处理器来执行命令 ?* ?*?Detailed?function?description ?* ?*?@param[in]?command:?包含被请求变量名称的?C?字符串 ?* ?*?@return?如果发生错误，则返回值为?-1，否则返回命令的状态。 ?*/ int?system(const?char?*command);
?
例子：通过system函数启动一个进程，列出当前目录下的文件及文件夹。
?
#include?
#include?
int?main(void)
{
????system("ls");
????printf("ls?end
");
????return?0;
}
?
（2）通过fork函数启动进程。（用于启动子进程）
?
#include? #include? /** ?*?@brief?fork系统调用用于创建一个子进程 ?* ?*?Detailed?function?description ?* ?*?@param[in] ?* ?*?@return?如果发生错误，则返回值为?-1，否则返回命令的状态。 ?*/ pid_t?fork(void);
?
例子：通过fork函数启动子进程
?
#include?
#include?
#include?
#include?
int?main(void)?
{
????pid_t?res?=?fork();
????///?0)?
????{
????????printf("res?=?%d,?I?am?parent?process.?pid?=?%d
",?res,?getpid());
????????int?child_status?=?0;
????????pid_t?child_pid?=?wait(&child_status);???///
?
编译、运行：
我们使用了fork()系统调用来创建一个新进程。如果fork()返回值为0，则说明当前进程是子进程；如果返回值大于0，则说明当前进程是父进程。在父进程中，我们使用wait()系统调用来等待子进程结束。当子进程结束后，父进程会继续执行。
（3）通过exec系列函数启动进程。（用于启动新进程，新进程会覆盖旧进程）
?
#include?
/**
?*?@brief?启动新进程，新进程会覆盖旧进程
?*
?*?Detailed?function?description
?*
?*?@param[in]?path:?所执行文件的路径
?*?@param[in]?file:?所执行文件的名称
?*?@param[in]?arg:?传入的参数列表，以NULL作为结束
?*?@param[in]?envp:?传入的环境变量
?*
?*?@return?如果发生错误，则返回值为?-1，否则返回命令的状态。
?*/
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()函数的参数列表调用了ls命令程序
?
#include?
#include?
int?main(void)
{
????execl("/bin/ls",?"ls",?"-la",?NULL);
????printf("ls?end
");
????return?0;
}
?
execl()函数的参数列表调用了ls命令程序，与在终端上运行”ls -la”产生的结果是一样的。
在Linux中终止一个进程有多种方法：
从main函数返回。（正常终止）
调用exit()函数终止。（正常终止）
调用_exit()函数终止。（正常终止）
调用abort()函数终止。（异常终止）
由系统信号终止。（异常终止）
进程间通信方式
进程间通信是指在不同进程之间传播或交换信息的一种机制。每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程A把数据从用户空间拷到内核缓冲区，进程B再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信。
进程间通信的目的：
传输数据。比如进程 A 负责生成数据，进程 B 负责处理数据，数据需要从 A 进程传输至 B 进程。
共享资源。比如进程 A 与进程 B 共享某一块内存资源。
模块化。将系统功能划分为多个进程模块进行开发，方便开发维护。
加速计算。多核处理器环境，一个特定进程划分为几个进程并行运行。
Linux IPC（Inter-process Comminication， 进程间通信）的方式：
1、消息队列
内核中的一个优先级队列，多个进程通过访问同一个队列，进行添加结点或者获取结点实现通信。
POSIX消息队列头文件：
?
#include????????????/*?For?O_*?constants?*/
#include?????????/*?For?mode?constants?*/
#include?
?
编译链接需要加上 -lrt 链接。
消息队列API接口：
?
/**
?*?@brief?创建消息队列实例
?*
?*?Detailed?function?description
?*
?*?@param[in]?name:?消息队列名称
?*?@param[in]?oflag：根据传入标识来创建或者打开一个已创建的消息队列
????????????????????-?O_CREAT:?创建一个消息队列
????????????????????-?O_EXCL:?检查消息队列是否存在，一般与O_CREAT一起使用
????????????????????-?O_CREAT|O_EXCL:?消息队列不存在则创建，已存在返回NULL
????????????????????-?O_NONBLOCK:?非阻塞模式打开，消息队列不存在返回NULL
????????????????????-?O_RDONLY:?只读模式打开
????????????????????-?O_WRONLY:?只写模式打开
????????????????????-?O_RDWR:?读写模式打开
?*?@param[in]?mode：访问权限
?*?@param[in]?attr：消息队列属性地址
?*
?*?@return?成功返回消息队列描述符，失败返回-1，错误码存于error中
?*/
mqd_t?mq_open(const?char?*name,?int?oflag,??mode_t?mode,?struct?mq_attr?*attr);
/**
?*?@brief?无限阻塞方式接收消息
?*
?*?Detailed?function?description
?*
?*?@param[in]?mqdes:?消息队列描述符
?*?@param[in]?msg_ptr：消息体缓冲区地址
?*?@param[in]?msg_len：消息体长度，长度必须大于等于消息属性设定的最大值
?*?@param[in]?msg_prio：消息优先级
?*
?*?@return?成功返回消息长度，失败返回-1，错误码存于error中
?*/
mqd_t?mq_receive(mqd_t?mqdes,?char?*msg_ptr,?size_t?msg_len,?unsigned?*msg_prio);
/**
?*?@brief?指定超时时间阻塞方式接收消息
?*
?*?Detailed?function?description
?*
?*?@param[in]?mqdes:?消息队列描述符
?*?@param[in]?msg_ptr：消息体缓冲区地址
?*?@param[in]?msg_len：消息体长度，长度必须大于等于消息属性设定的最大值
?*?@param[in]?msg_prio：消息优先级
?*?@param[in]?abs_timeout：超时时间
?*
?*?@return?成功返回消息长度，失败返回-1，错误码存于error中
?*/
mqd_t?mq_timedreceive(mqd_t?mqdes,?char?*msg_ptr,?size_t?msg_len,?unsigned?*msg_prio,?const?struct?timespec?*abs_timeout);
/**
?*?@brief?无限阻塞方式发送消息
?*
?*?Detailed?function?description
?*
?*?@param[in]?mqdes:?消息队列描述符
?*?@param[in]?msg_ptr：待发送消息体缓冲区地址
?*?@param[in]?msg_len：消息体长度
?*?@param[in]?msg_prio：消息优先级
?*
?*?@return?成功返回0，失败返回-1
?*/
mqd_t?mq_send(mqd_t?mqdes,?const?char?*msg_ptr,?size_t?msg_len,?unsigned?msg_prio);
/**
?*?@brief?指定超时时间阻塞方式发送消息
?*
?*?Detailed?function?description
?*
?*?@param[in]?mqdes:?消息队列描述符
?*?@param[in]?msg_ptr：待发送消息体缓冲区地址
?*?@param[in]?msg_len：消息体长度
?*?@param[in]?msg_prio：消息优先级
?*?@param[in]?abs_timeout：超时时间
?*
?*?@return?成功返回0，失败返回-1
?*/
mqd_t?mq_timedsend(mqd_t?mqdes,?const?char?*msg_ptr,?size_t?msg_len,?unsigned?msg_prio,?const?struct?timespec?*abs_timeout);
/**
?*?@brief?关闭消息队列
?*
?*?Detailed?function?description
?*
?*?@param[in]?mqdes:?消息队列描述符
?*
?*?@return?成功返回0，失败返回-1
?*/
mqd_t?mq_close(mqd_t?mqdes);
/**
?*?@brief?分离消息队列
?*
?*?Detailed?function?description
?*
?*?@param[in]?name:?消息队列名称
?*
?*?@return?成功返回0，失败返回-1
?*/
mqd_t?mq_unlink(const?char?*name);
?
消息队列基本API接口使用例子：发送进程给接收进程发送测试数据。
send.c：
?
#include?
#include?
#include?
#include?
#include????????????/*?For?O_*?constants?*/
#include?????????/*?For?mode?constants?*/
#include?
#define?MQ_MSG_MAX_SIZE????512??///
?
recv.c：
?
#include?
#include?
#include?
#include?
#include????????????/*?For?O_*?constants?*/
#include?????????/*?For?mode?constants?*/
#include?
#define?MQ_MSG_MAX_SIZE????512??///
?
编译、运行：
?
gcc?send.c?-o?send_process?-lrt
gcc?recv.c?-o?recv_process?-lrt
?
2、共享内存
消息队列的读取和写入的过程，会有发生用户态与内核态之间的消息拷贝过程。而共享内存的方式则没有这个拷贝过程，进程间通信速度较快。
在物理内存上开辟一块内存空间，多个进程可以将同一块物理内存空间映射到自己的虚拟地址空间，通过自己的虚拟地址直接访问这块空间，通过这种方式实现数据共享。
POSIX共享内存头文件：
?
#include?
#include?
#include?
?
共享内存API接口：
?
/**
?*?@brief?创建共享内存实例
?*
?*?Detailed?function?description
?*
?*?@param[in]?name:?要打开或创建的共享内存文件名
?*?@param[in]?oflag：打开的文件操作属性
????????????????????-?O_CREAT:?创建一个共享内存文件
????????????????????-?O_EXCL:?检查共享内存是否存在，一般与O_CREAT一起使用
????????????????????-?O_CREAT|O_EXCL:?共享内存不存在则创建，已存在返回NULL
????????????????????-?O_NONBLOCK:?非阻塞模式打开，共享内存不存在返回NULL
????????????????????-?O_RDONLY:?只读模式打开
????????????????????-?O_WRONLY:?只写模式打开
????????????????????-?O_RDWR:?读写模式打开
?*?@param[in]?mode：文件共享模式，例如?0777
?*
?*?@return?成功返回共享内存描述符，失败返回-1，错误码存于error中
?*/
int?shm_open(const?char?*name,?int?oflag,?mode_t?mode);
/**
?*?@brief?删除共享内存
?*
?*?Detailed?function?description
?*
?*?@param[in]?name:?创建的共享内存文件名
?*
?*?@return?成功返回0，失败返回-1
?*/
int?shm_unlink(const?char?*name);
/**
?*?@brief?将打开的文件映射到内存
?*
?*?Detailed?function?description
?*
?*?@param[in]?addr:?要将文件映射到的内存地址，一般应该传递NULL来由Linux内核指定
?*?@param[in]?length:?要映射的文件数据长度
?*?@param[in]?prot:?映射的内存区域的操作权限（保护属性），包括PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE
?*?@param[in]?flags:?标志位参数，包括：MAP_SHARED、MAP_PRIVATE与MAP_ANONYMOUS。
?*?@param[in]?fd:??用来建立映射区的文件描述符，用?shm_open打开或者open打开的文件
?*?@param[in]?offset:?映射文件相对于文件头的偏移位置，应该按4096字节对齐
?*
?*?@return?成功返回0，失败返回-1
?*/
void?*mmap(void?*addr,?size_t?length,?int?prot,?int?flags,?int?fd,?off_t?offset);
?
/**
?*?@brief?取消内存映射
?*
?*?Detailed?function?description
?*
?*?@param[in]?addr:?由mmap成功返回的地址
?*?@param[in]?length:?要取消的内存长度
?*
?*?@return?成功返回0，失败返回-1
?*/
int?munmap(void?*addr,?size_t?length);
/**
?*?@brief?将参数fd指定的文件大小改为参数length指定的大小
?*
?*?Detailed?function?description
?*
?*?@param[in]?fd:?已打开的文件描述符，以写入模式打开的文件
?*?@param[in]?length:?要设置的长度
?*
?*?@return?成功返回0，失败返回-1
?*/
int?ftruncate(int?fd,off_t?length);
/**
?*?@brief?获取文件相关的信息，将获取到的信息放入到statbuf结构体中
?*
?*?Detailed?function?description
?*
?*?@param[in]?fd:?已打开的文件描述符
?*?@param[out]?statbuf:?文件的信息
?*
?*?@return?成功返回0，失败返回-1
?*/
int?fstat(int?fd,?struct?stat?*statbuf);
?
共享内存基本API接口使用例子：发送进程给接收进程发送测试数据。
send.c：
?
#include?
#include?
#include?
#include?
#include????????????/*?For?O_*?constants?*/
#include?????????/*?For?mode?constants?*/
#include?
#define?SHM_NAME?"/shm"
int?main(void)
{
????int?ret?=?0;
????///
?
recv.c：
?
#include?
#include?
#include?
#include?
#include????????????/*?For?O_*?constants?*/
#include?????????/*?For?mode?constants?*/
#include?
#define?SHM_NAME?"/shm"
int?main(void)
{
????///
?
编译、运行：
?
gcc?send.c?-o?send_process?-lrt
gcc?recv.c?-o?recv_process?-lrt
?
对具有多个处理核系统消息传递的性能要优于共享内存。共享内存会有高速缓存一致性问题，这是由共享数据在多个高速缓存之间迁移而引起的。随着系统的处理核的数量的日益增加，可能导致消息传递作为 IPC 的首选机制。
3、socket
UNIX域套接字与传统基于TCP/IP协议栈的socket不同，unix domain socket以文件系统作为地址空间，不需经过TCP/IP的头部封装、报文ack确认、路由选择、数据校验与重传过程，因此传输速率上也不会受网卡带宽的限制。
unix domain socket在进程间通信同样是基于“客户端—服务器”（C-S）模式。
UNIX域套接字基本API接口使用例子：基于UNIX域套接字客户端进程向服务端进程发送测试数据。
server.c：
?
#include?
#include?
#include?
#include?
#include????????????/*?For?O_*?constants?*/
#include?????????/*?For?mode?constants?*/
#include?
#include?
#include?
#include?
#define?SERVER_PATH?"/tmp/server"?
int?main(void)
{
?///
?
client.c：
?
#include?
#include?
#include?
#include?
#include????????????/*?For?O_*?constants?*/
#include?????????/*?For?mode?constants?*/
#include?
#include?
#include?
#include?
#define?SERVER_PATH?"/tmp/server"
#define?CLIENT_PATH?"/tmp/client"
int?main(void)
{
?///
?
编译、运行：
?
gcc?server.c?-o?server_process
gcc?client.c?-o?client_process
?
类socket的其它进程间通信方式：
实用 | nanomsg通信库的简单使用分享
mqtt应用于进程间通信
4、管道
在内核中开辟一块缓冲区；若多个进程拿到同一个管道(缓冲区)的操作句柄，就可以访问同一个缓冲区，就可以进行通信。涉及到两次用户态与内核态之间的数据拷贝。
（1）匿名管道
内核中的缓冲区是没有具体的标识符的，匿名管道只能用于具有亲缘关系的进程间通信。
调用pipe接口可以创建一个匿名管道，并返回了两个描述符，一个是管道的读取端描述符 fd[0]，另一个是管道的写入端描述符 fd[1]。
管道是一个半双工通信(可以选择方向的单向传输)
匿名管道基本API接口使用例子：父进程通过管道发送测试数据给子进程。
?
#include?
#include?
#include?
#include?
int?main()
{
????///?0)
???{
??///
?
编译、运行：
如果需要双向通信，则应该创建两个管道。
（2）命名管道
命名管道也是内核中的一块缓冲区，并且这个缓冲区具有标识符；这个标识符是一个可见于文件系统的管道文件，能够被其他进程找到并打开管道文件，则可以获取管道的操作句柄，所以该命名管道可用于同一主机上的任意进程间通信。
创建命名管道的接口：
?
int?mkfifo(const?char?*pathname,?mode_t?mode);
?
命名管道基本API接口使用例子：一个进程往管道中写入测试数据，另一个进程从管道中读取数据。
fifo_wr.c：
?
#include?
#include?
#include?
#include?
#include?
#include?
#include?
#define?FIFO_PATH??"./fifo_file"
typedef?struct?_msg_data
{
????char?buf[128];
????int?cnt;
}msg_data_t;
void?send_data(int?fd)
{
????static?int?cnt?=?0;
????msg_data_t?send_data?=?{0};
????cnt++;
????strcpy(send_data.buf,?"hello");
????send_data.cnt?=?cnt;
????write(fd,?&send_data,?sizeof(send_data));
????printf("send?msg?=?%s,?cnt?=?%d
",?send_data.buf,?send_data.cnt);
}
int?main(void)
{
????///
?
fifo_rd.c：
?
#include?
#include?
#include?
#include?
#include?
#include?
#include?
#define?FIFO_PATH??"./fifo_file"
typedef?struct?_msg_data
{
????char?buf[128];
????int?cnt;
}msg_data_t;
int?main(void)
{
????umask(0);
????///
?
编译、运行：
?
gcc?fifo_wr.c?-o?fifo_wr
gcc?fifo_rd.c?-o?fifo_rd
?
5、信号量
信号量（Seamphore）是进程和线程间同步的一种机制。
信号量本质是一个非负的整型变量。增加一个可用资源执行加一，也称为V操作；获取一个资源资源后执行减一，也称为P操作。
信号量根据信号值不同可分为两类：
二值信号量，信号量值只有0和1，初始值为1，1表示资源可用，0表示资源不可用；二值信号量与互斥锁类似。
计数信号量， 信号量的值在0到一个大于1的限制值之间，信号值表示可用的资源的数目。
信号量根据作用对象不同可分为两类：
有名信号量，信号值保存在文件中，用于进程间同步
无名信号量，又称为基于内存信号量，信号值保存在内存中，用于线程间同步
POSIX信号量头文件：
?
#include?
?
编译链接需要加-lpthread参数。
信号量API接口：
?
/**
?*?@brief?创建信号量
?*
?*?Detailed?function?description
?*
?*?@param[in]?name:?信号量名称
?*?@param[in]?mode:?访问权限
?*?@param[in]?value:?信号量初始值
?*
?*?@return?成功时返回指向信号量的指针，出错时为SEM_FAILED
?*/
sem_t?*sem_open(const?char?*name,int?oflag,?mode_t?mode,?unsigned?int?value);
/**
?*?@brief?初始化信号量
?*
?*?Detailed?function?description
?*
?*?@param[in]?sem:?信号量实例地址
?*?@param[in]?pshared:?信号量作用域，分为进程内作用域PTHREAD_PROCESS_PRIVATE和跨进程作用域PTHREAD_PROCESS_SHARED
?*?@param[in]?value:?信号量初始值
?*
?*?@return?成功返回0，失败返回-1
?*/
int?sem_init(sem_t?*sem,?int?pshared,?unsigned?int?value);
/**
?*?@brief?获取信号量
?*
?*?Detailed?function?description
?*
?*?@param[in]?sem:?信号量实例地址
?*?@param[out]?sval:?保存返回信号值地址
?*
?*?@return?成功返回0，失败返回-1
?*/
int?sem_getvalue(sem_t?*sem,?int?*sval);
/**
?*?@brief?阻塞方式等待信号量
?*
?*?Detailed?function?description
?*
?*?@param[in]?sem:?信号量实例地址
?*
?*?@return?成功返回0，失败返回-1
?*/
int?sem_wait(sem_t?*sem);
/**
?*?@brief?指定超时时间阻塞方式等待信号量
?*
?*?Detailed?function?description
?*
?*?@param[in]?sem:?信号量实例地址
?*?@param[in]?sem:?超时时间，单位为时钟节拍
?*
?*?@return?成功返回0，失败返回-1
?*/
int?sem_timedwait(sem_t?*sem,?const?struct?timespec?*abs_timeout);
/**
?*?@brief?非阻塞方式等待信号量
?*
?*?Detailed?function?description
?*
?*?@param[in]?sem:?信号量实例地址
?*
?*?@return?成功返回0，失败返回-1
?*/
int?sem_trywait(sem_t?*sem);
/**
?*?@brief?产生信号量
?*
?*?Detailed?function?description
?*
?*?@param[in]?sem:?信号量实例地址
?*
?*?@return?成功返回0，失败返回-1
?*/
int?sem_post(sem_t?*sem);
/**
?*?@brief?销毁信号量
?*
?*?Detailed?function?description
?*
?*?@param[in]?sem:?信号量实例地址
?*
?*?@return?成功返回0，失败返回-1
?*/
int?sem_destroy(sem_t?*sem);
/**
?*?@brief?关闭信号量
?*
?*?Detailed?function?description
?*
?*?@param[in]?sem:?信号量实例地址
?*
?*?@return?成功返回0，失败返回-1
?*/
int?sem_close(sem_t?*sem);
/**
?*?@brief?分离信号量
?*
?*?Detailed?function?description
?*
?*?@param[in]?name:?信号量名称
?*
?*?@return?成功返回0，失败返回-1
?*/
int?sem_unlink(const?char?*name);
?
信号量基本API接口使用例子：父子进程间通信
?
#include?
#include?
#include?
#include?
#include?
#define?SEM_NAME?"sem"
int?main?(void)
{
????int?sem_val?=?0;
????///?0)
????{
????????///
?
编译、运行：
IPC总结
操作系统根据不同的场景提供了不同的方式，消息队列、共享内存、UNIX域套接字、管道、信号量。
消息队列： 内核中的一个优先级队列，多个进程通过访问同一个队列，在队列当中添加或者获取节点来实现进程间通信。
共享内存： 本质是一块物理内存，多个进程将同一块物理内存映射到自己的虚拟地址空间中，再通过页表映射到物理地址达到进程间通信，它是最快的进程间通信方式，相较其他通信方式少了两步数据拷贝操作。
UNIX域套接字： 与TCP/IP套接字使用方式相同，但UNIX域套接字以文件系统作为地址空间，不需经过TCP/IP的头部封装、报文ack确认、路由选择、数据校验与重传过程，因此传输速率上也不会受网卡带宽的限制。
管道： 内核中的一块缓冲区，分为匿名管道和命名管道。匿名管道只能用于具有亲缘关系的进程间；而命名管道可用于同一主机上任意进程间通信。
信号量： 本质是内核中的一个计数器，主要实现进程间的同步与互斥，对资源进行计数，有两种操作，分别是在访问资源之前进行的p操作，还有产生资源之后的v操作。
审核编辑：汤梓红
工商网监
评论