什麼是程序
1、程序和線程的差別
程序是指正在運作的程式,它擁有獨立的記憶體空間和系統資源,不同程序之間的資料不共享。程序是資源配置設定的基本機關。
線程是程序内的執行單元,它與同一程序内的其他線程共享程序的記憶體空間和系統資源。線程是排程的基本機關。
2、程序的建立和銷毀
在Linux中啟動一個程序有多種方法:
(1)通過system函數啟動程序。(使用簡單,效率較低)
#include <stdlib.h>
/**
* @brief 執行系統指令調用指令處理器來執行指令
*
* Detailed function description
*
* @param[in] command: 包含被請求變量名稱的 C 字元串
*
* @return 如果發生錯誤,則傳回值為 -1,否則傳回指令的狀态。
*/
int system(const char *command);
例子:通過system函數啟動一個程序,列出目前目錄下的檔案及檔案夾。
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
system("ls");
printf("ls end\n");
return 0;
}
(2)通過fork函數啟動程序。(用于啟動子程序)
#include <sys/types.h>
#include <unistd.h>
/**
* @brief fork系統調用用于建立一個子程序
*
* Detailed function description
*
* @param[in]
*
* @return 如果發生錯誤,則傳回值為 -1,否則傳回指令的狀态。
*/
pid_t fork(void);
例子:通過fork函數啟動子程序
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
int main(void)
{
pid_t res = fork();
///< 子程序
if (res == 0)
{
printf("res = %d, I am child process. pid = %d\n", res, getpid());
exit(EXIT_SUCCESS); ///< 正常退出子程序
}
///< 父程序
else if (res > 0)
{
printf("res = %d, I am parent process. pid = %d\n", res, getpid());
int child_status = 0;
pid_t child_pid = wait(&child_status); ///< 父程序阻塞等待信号到來或子程序結束
printf("Child process(pid = %d) has been terminated, child_status = %d\n", child_pid, child_status);
}
///< 異常退出
else
{
printf("Fork failed.\n");
exit(EXIT_FAILURE);
}
return 0;
}
編譯、運作:
我們使用了fork()系統調用來建立一個新程序。如果fork()傳回值為0,則說明目前程序是子程序;如果傳回值大于0,則說明目前程序是父程序。在父程序中,我們使用wait()系統調用來等待子程序結束。當子程序結束後,父程序會繼續執行。
(3)通過exec系列函數啟動程序。(用于啟動新程序,新程序會覆寫舊程序)
#include <unistd.h>
/**
* @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 <stdio.h>
#include <unistd.h>
int main(void)
{
execl("/bin/ls", "ls", "-la", NULL);
printf("ls end\n");
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 <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <mqueue.h>
編譯連結需要加上 -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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <mqueue.h>
#define MQ_MSG_MAX_SIZE 512 ///< 最大消息長度
#define MQ_MSG_MAX_ITEM 5 ///< 最大消息數目
static mqd_t s_mq;
typedef struct _msg_data
{
char buf[128];
int cnt;
}msg_data_t;
void send_data(void)
{
static int cnt = 0;
msg_data_t send_data = {0};
cnt++;
strcpy(send_data.buf, "hello");
send_data.cnt = cnt;
int ret = mq_send(s_mq, (char*)&send_data, sizeof(send_data), 0);
if (ret < 0)
{
perror("mq_send error");
return;
}
printf("send msg = %s, cnt = %d\n", send_data.buf, send_data.cnt);
}
int main(void)
{
int ret = 0;
struct mq_attr attr;
///< 建立消息隊列
memset(&attr, 0, sizeof(attr));
attr.mq_maxmsg = MQ_MSG_MAX_ITEM;
attr.mq_msgsize = MQ_MSG_MAX_SIZE;
attr.mq_flags = 0;
s_mq = mq_open("/mq", O_CREAT|O_RDWR, 0777, &attr);
if(-1 == s_mq)
{
perror("mq_open error");
return -1;
}
for (size_t i = 0; i < 10; i++)
{
send_data();
sleep(1);
}
mq_close(s_mq);
return 0;
}
recv.c:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <mqueue.h>
#define MQ_MSG_MAX_SIZE 512 ///< 最大消息長度
#define MQ_MSG_MAX_ITEM 5 ///< 最大消息數目
static mqd_t s_mq;
typedef struct _msg_data
{
char buf[128];
int cnt;
}msg_data_t;
int main(void)
{
int ret = 0;
struct mq_attr attr;
char recv_msg[MQ_MSG_MAX_SIZE] = {0};
msg_data_t recv_data = {0};
int prio = 0;
ssize_t len = 0;
s_mq = mq_open("/mq", O_RDONLY);
if(-1 == s_mq)
{
perror("mq_open error");
return -1;
}
while (1)
{
if((len = mq_receive(s_mq, (char*)&recv_data, MQ_MSG_MAX_SIZE, &prio)) == -1)
{
perror("mq_receive error");
return -1;
}
printf("recv_msg = %s, cnt = %d\n", recv_data.buf, recv_data.cnt);
sleep(1);
}
mq_close(s_mq);
mq_unlink("/mq");
return 0;
}
編譯、運作:
gcc send.c -o send_process -lrt
gcc recv.c -o recv_process -lrt
2、共享記憶體
消息隊列的讀取和寫入的過程,會有發生使用者态與核心态之間的消息拷貝過程。而共享記憶體的方式則沒有這個拷貝過程,程序間通信速度較快。
在實體記憶體上開辟一塊記憶體空間,多個程序可以将同一塊實體記憶體空間映射到自己的虛拟位址空間,通過自己的虛拟位址直接通路這塊空間,通過這種方式實作資料共享。
POSIX共享記憶體頭檔案:
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
共享記憶體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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <sys/mman.h>
#define SHM_NAME "/shm"
int main(void)
{
int ret = 0;
///< 建立和讀端相同的檔案辨別
int shm_fd = shm_open(SHM_NAME, O_RDWR | O_CREAT, 0666);
if (shm_fd == -1)
{
printf("shm_open error\n");
}
///< 設定共享記憶體檔案為8KB
ftruncate(shm_fd , 8 * 1024);
///< 擷取共享記憶體檔案相關屬性資訊
struct stat filestat = {0};
fstat(shm_fd, &filestat);
printf("st_size = %ld\n",filestat.st_size);
///< 記憶體映射
char *shm_ptr = (char*)mmap(NULL, filestat.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, shm_fd, 0);
close(shm_fd);
///< 向共享記憶體中寫入資料
char buf[] = "hello world";
memmove(shm_ptr,buf, sizeof(buf));
printf("pid %d, %s\n",getpid(), shm_ptr);
///< 寫入完成後解除映射
munmap(shm_ptr, filestat.st_size);
return 0;
}
recv.c:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <sys/mman.h>
#define SHM_NAME "/shm"
int main(void)
{
///< 建立共享記憶體檔案辨別符
int shm_fd = shm_open(SHM_NAME, O_RDWR | O_CREAT, 0666);
if (shm_fd == -1)
{
printf("shm_open failed\n");
exit(EXIT_FAILURE);
}
///< 設定共享記憶體檔案為8KB
ftruncate(shm_fd , 8192);
///< 擷取共享記憶體檔案相關屬性資訊
struct stat filestat;
fstat(shm_fd, &filestat);
printf("st_size = %ld\n",filestat.st_size);
///< 映射共享記憶體,并擷取共享記憶體的位址
char *shm_ptr = (char*)mmap(NULL, filestat.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, shm_fd, 0);
close(shm_fd);
///< 擷取共享記憶體位址中的内容并列印,最後再解除映射,删除共享記憶體
printf("pid = %d, %s\n", getpid(), shm_ptr);
munmap(shm_ptr, filestat.st_size);
shm_unlink(SHM_NAME);
return 0;
}
編譯、運作:
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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/un.h>
#define SERVER_PATH "/tmp/server"
int main(void)
{
///< 建立UNIX域位元組流套接字
int server_fd = socket(AF_LOCAL, SOCK_STREAM, 0);
if(server_fd < 0)
{
printf("socket error\n");
exit(EXIT_FAILURE);
}
///< 綁定服務端位址
unlink(SERVER_PATH);
struct sockaddr_un server_addr;
memset((char*)&server_addr, 0, sizeof(server_addr));
server_addr.sun_family = AF_LOCAL;
strncpy(server_addr.sun_path, SERVER_PATH, sizeof(server_addr.sun_path)-1);
if(bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0)
{
printf("bind error\n");
close(server_fd);
exit(EXIT_FAILURE);
}
///< 監聽
if(listen(server_fd, 10) < 0)
{
printf("listen error\n");
close(server_fd);
exit(EXIT_FAILURE);
}
///< 等待用戶端連接配接
int addr_len = sizeof(struct sockaddr);
struct sockaddr_un client_addr;
int client_fd = accept(server_fd, (struct sockaddr*)&client_addr, (socklen_t *)&addr_len);
if(client_fd < 0)
{
printf("accept error\n");
close(server_fd);
unlink(SERVER_PATH);
exit(1);
}
else
{
printf("connected client: %s\n", client_addr.sun_path);
}
while(1)
{
char buf[128] = {0};
int recv_len = read(client_fd, buf, sizeof(buf));
if(recv_len <= 0)
{
printf("recv error!\n");
close(client_fd);
exit(EXIT_FAILURE);
}
printf("recv : %s\n", buf);
}
unlink(SERVER_PATH);
close(server_fd);
close(client_fd);
return 0;
}
client.c:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/un.h>
#define SERVER_PATH "/tmp/server"
#define CLIENT_PATH "/tmp/client"
int main(void)
{
///< 建立UNIX域位元組流套接字
int client_fd = socket(AF_UNIX, SOCK_STREAM, 0);
if(client_fd < 0)
{
printf("socket error\n");
exit(EXIT_FAILURE);
}
///< 顯式綁定用戶端位址
struct sockaddr_un client_addr;
memset((char*)&client_addr, 0, sizeof(client_addr));
client_addr.sun_family = AF_UNIX;
strncpy(client_addr.sun_path, CLIENT_PATH, sizeof(client_addr.sun_path)-1);
unlink(CLIENT_PATH);
if(bind(client_fd, (struct sockaddr*)&client_addr, sizeof(client_addr)) < 0)
{
printf("bind error\n");
close(client_fd);
exit(1);
}
///< 連接配接服務端
struct sockaddr_un server_addr;
server_addr.sun_family = AF_UNIX;
strncpy(server_addr.sun_path, SERVER_PATH, sizeof(server_addr.sun_path)-1);
int ret = connect(client_fd, (struct sockaddr*)&server_addr, sizeof(server_addr));
if(ret < 0)
{
printf("connect error\n");
close(client_fd);
unlink(CLIENT_PATH);
exit(1);
}
printf("connect to server: %s\n", server_addr.sun_path);
while(1)
{
char buf[128] = {0};
if (scanf("%s", buf))
{
int send_len = write(client_fd, buf, strlen(buf));
if (send_len <= 0)
{
printf("write error!\n");
close(client_fd);
exit(EXIT_FAILURE);
}
else
{
printf("send success! send: %s, send_len: %d\n", buf, send_len);
}
}
}
unlink(SERVER_PATH);
close(client_fd);
return 0;
}
編譯、運作:
gcc server.c -o server_process
gcc client.c -o client_process
類socket的其它程序間通信方式:
實用 | nanomsg通信庫的簡單使用分享
mqtt應用于程序間通信
4、管道
在核心中開辟一塊緩沖區;若多個程序拿到同一個管道(緩沖區)的操作句柄,就可以通路同一個緩沖區,就可以進行通信。涉及到兩次使用者态與核心态之間的資料拷貝。
(1)匿名管道
核心中的緩沖區是沒有具體的辨別符的,匿名管道隻能用于具有親緣關系的程序間通信。
調用pipe接口可以建立一個匿名管道,并傳回了兩個描述符,一個是管道的讀取端描述符 fd[0],另一個是管道的寫入端描述符 fd[1]。
管道是一個半雙工通信(可以選擇方向的單向傳輸)
匿名管道基本API接口使用例子:父程序通過管道發送測試資料給子程序。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main()
{
///< 建立管道
int pipefd[2] = {-1};
int ret = pipe(pipefd);
if (ret < 0)
{
printf("pipe error\n");
exit(EXIT_FAILURE);
}
int read_fd = pipefd[0]; ///< pipefd[0] 用于從管道中讀取資料
int write_fd = pipefd[1]; ///< pipefd[1] 用于向管道中寫入資料
///< 建立子程序
pid_t pid = fork();
if (pid == 0)
{
///< 子程序從管道讀取資料
char buf[128] = {0};
read(read_fd, buf, sizeof(buf));
printf("child recv data from father: %s", buf);
}
else if (pid > 0)
{
///< 父程序向管道寫入資料
char *ptr = "hello88888888\n";
write(write_fd, ptr, strlen(ptr));
}
return 0;
}
編譯、運作:
如果需要雙向通信,則應該建立兩個管道。
(2)命名管道
命名管道也是核心中的一塊緩沖區,并且這個緩沖區具有辨別符;這個辨別符是一個可見于檔案系統的管道檔案,能夠被其他程序找到并打開管道檔案,則可以擷取管道的操作句柄,是以該命名管道可用于同一主機上的任意程序間通信。
建立命名管道的接口:
int mkfifo(const char *pathname, mode_t mode);
命名管道基本API接口使用例子:一個程序往管道中寫入測試資料,另一個程序從管道中讀取資料。
fifo_wr.c:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#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\n", send_data.buf, send_data.cnt);
}
int main(void)
{
///< 建立管道檔案
int ret = mkfifo(FIFO_PATH, 0664);
if (ret < 0 && errno != EEXIST)
{
printf("mkfifo error\n");
exit(EXIT_FAILURE);
}
///< 以隻寫的方式打開管道檔案
int fd = open(FIFO_PATH, O_WRONLY);
if (fd < 0)
{
printf("open fifo error\n");
exit(EXIT_FAILURE);
}
printf("open fifo success\n");
///< 寫10次
for (size_t i = 0; i < 10; i++)
{
send_data(fd);
sleep(1);
}
close(fd);
return 0;
}
fifo_rd.c:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#define FIFO_PATH "./fifo_file"
typedef struct _msg_data
{
char buf[128];
int cnt;
}msg_data_t;
int main(void)
{
umask(0);
///< 建立管道檔案
int ret = mkfifo(FIFO_PATH,0664 );
if (ret < 0 && errno != EEXIST)
{
printf("mkfifo error\n");
exit(EXIT_FAILURE);
}
///< 以隻讀方式擷取管道檔案的操作句柄
int fd = open(FIFO_PATH, O_RDONLY);
if (fd < 0)
{
printf("open error\n");
exit(EXIT_FAILURE);
}
printf("open fifo success\n");
while(1)
{
msg_data_t read_data = {0};
///< 将從管道讀取的檔案寫到buf中
int ret = read(fd, &read_data, sizeof(read_data));
if (ret < 0)
{
printf("read error\n");
exit(EXIT_FAILURE);
}
else if (ret == 0)
{
printf("all write closed\nd");
exit(EXIT_FAILURE);
}
printf("read_data = %s, cnt = %d\n", read_data.buf, read_data.cnt);
sleep(1);
}
close(fd);
return 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 <semaphore.h>
編譯連結需要加-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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>
#include <fcntl.h>
#define SEM_NAME "sem"
int main (void)
{
int sem_val = 0;
///< 建立信号量
sem_t *sem = sem_open(SEM_NAME, O_CREAT, 0666, 1);
if (NULL == sem)
{
printf("sem_open error\n");
exit(EXIT_FAILURE);
}
///< 建立子程序
pid_t pid = fork();
if (pid == -1)
{
printf("fork error\n");
sem_close(sem);
sem_unlink(SEM_NAME);
exit(EXIT_FAILURE);
}
else if(pid == 0)
{
///< 子程序進行5次P操作
for (size_t i = 0; i < 5; i++)
{
sem_wait(sem);
if (sem_getvalue(sem, &sem_val) != -1)
{
printf("child process P operation, sem_val = %d\n", sem_val);
sleep(1);
}
}
_exit(1);
}
else if (pid > 0)
{
///< 父程序執行5次V操作
for (size_t i = 0; i < 5; i++)
{
sem_post(sem);
if (sem_getvalue(sem, &sem_val) != -1)
{
printf("prarent process V operation, sem_val = %d\n", sem_val);
sleep(2);
}
}
}
///< 删除sem信号量
sem_close(sem);
if (sem_unlink(SEM_NAME) != -1)
{
printf("sem_unlink success\n");
}
return 0;
}
編譯、運作:
IPC總結
作業系統根據不同的場景提供了不同的方式,消息隊列、共享記憶體、UNIX域套接字、管道、信号量。
消息隊列: 核心中的一個優先級隊列,多個程序通過通路同一個隊列,在隊列當中添加或者擷取節點來實作程序間通信。
共享記憶體: 本質是一塊實體記憶體,多個程序将同一塊實體記憶體映射到自己的虛拟位址空間中,再通過頁表映射到實體位址達到程序間通信,它是最快的程序間通信方式,相較其他通信方式少了兩步資料拷貝操作。
UNIX域套接字: 與TCP/IP套接字使用方式相同,但UNIX域套接字以檔案系統作為位址空間,不需經過TCP/IP的頭部封裝、封包ack确認、路由選擇、資料校驗與重傳過程,是以傳輸速率上也不會受網卡帶寬的限制。
管道: 核心中的一塊緩沖區,分為匿名管道和命名管道。匿名管道隻能用于具有親緣關系的程序間;而命名管道可用于同一主機上任意程序間通信。
信号量: 本質是核心中的一個計數器,主要實作程序間的同步與互斥,對資源進行計數,有兩種操作,分别是在通路資源之前進行的p操作,還有産生資源之後的v操作。
相關資料:
- https://xiaolincoding.com/os/4_process/process_commu.html
- https://blog.csdn.net/sjsjnsjnn/article/details/125864580
- https://huaweicloud.csdn.net/63564439d3efff3090b5cdec.html
- https://blog.51cto.com/u_13456560/5822959
如果文章對你有幫助,麻煩幫忙點贊、收藏、轉發,謝謝!
私信回複【嵌入式書籍】,可擷取部落客精心整理的嵌入式電子書一份