0
  • 聊天消息
  • 系統(tǒng)消息
  • 評論與回復
登錄后你可以
  • 下載海量資料
  • 學習在線課程
  • 觀看技術視頻
  • 寫文章/發(fā)帖/加入社區(qū)
會員中心
創(chuàng)作中心

完善資料讓更多小伙伴認識你,還能領取20積分哦,立即完善>

3天內(nèi)不再提示

程序中進程和線程的區(qū)別

科技綠洲 ? 來源:嵌入式大雜燴 ? 作者:嵌入式大雜燴 ? 2023-06-22 11:39 ? 次閱讀

什么是進程

1、進程和線程的區(qū)別

進程是指正在運行的程序,它擁有獨立的內(nèi)存空間和系統(tǒng)資源,不同進程之間的數(shù)據(jù)不共享。進程是資源分配的基本單位。

線程是進程內(nèi)的執(zhí)行單元,它與同一進程內(nèi)的其他線程共享進程的內(nèi)存空間和系統(tǒng)資源。線程是調度的基本單位。

2、進程的創(chuàng)建和銷毀

Linux中啟動一個進程有多種方法:

(1)通過system函數(shù)啟動進程。(使用簡單,效率較低)

#include < stdlib.h >

/**
 * @brief 執(zhí)行系統(tǒng)命令調用命令處理器來執(zhí)行命令
 *
 * Detailed function description
 *
 * @param[in] command: 包含被請求變量名稱的 C 字符串
 *
 * @return 如果發(fā)生錯誤,則返回值為 -1,否則返回命令的狀態(tài)。
 */
int system(const char *command);

例子:通過system函數(shù)啟動一個進程,列出當前目錄下的文件及文件夾。

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

int main(void)
{
    system("ls");
    printf("ls end\\n");

    return 0;
}

(2)通過fork函數(shù)啟動進程。(用于啟動子進程)

#include < sys/types.h >
#include < unistd.h >

/**
 * @brief fork系統(tǒng)調用用于創(chuàng)建一個子進程
 *
 * Detailed function description
 *
 * @param[in]
 *
 * @return 如果發(fā)生錯誤,則返回值為 -1,否則返回命令的狀態(tài)。
 */
pid_t fork(void);

例子:通過fork函數(shù)啟動子進程

#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()系統(tǒng)調用來創(chuàng)建一個新進程。如果fork()返回值為0,則說明當前進程是子進程;如果返回值大于0,則說明當前進程是父進程。在父進程中,我們使用wait()系統(tǒng)調用來等待子進程結束。當子進程結束后,父進程會繼續(xù)執(zhí)行。

(3)通過exec系列函數(shù)啟動進程。(用于啟動新進程,新進程會覆蓋舊進程)

#include < unistd.h >

/**
 * @brief 啟動新進程,新進程會覆蓋舊進程
 *
 * Detailed function description
 *
 * @param[in] path: 所執(zhí)行文件的路徑
 * @param[in] file: 所執(zhí)行文件的名稱
 * @param[in] arg: 傳入的參數(shù)列表,以NULL作為結束
 * @param[in] envp: 傳入的環(huán)境變量
 *
 * @return 如果發(fā)生錯誤,則返回值為 -1,否則返回命令的狀態(tài)。
 */
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()函數(shù)的參數(shù)列表調用了ls命令程序

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

int main(void)
{
    execl("/bin/ls", "ls", "-la", NULL);
    printf("ls end\\n");
    return 0;
}

execl()函數(shù)的參數(shù)列表調用了ls命令程序,與在終端上運行”ls -la”產(chǎn)生的結果是一樣的。

在Linux中終止一個進程有多種方法:

  • 從main函數(shù)返回。(正常終止)
  • 調用exit()函數(shù)終止。(正常終止)
  • 調用_exit()函數(shù)終止。(正常終止)
  • 調用abort()函數(shù)終止。(異常終止)
  • 由系統(tǒng)信號終止。(異常終止)

進程間通信方式

進程間通信是指在不同進程之間傳播或交換信息的一種機制。每個進程各自有不同的用戶地址空間,任何一個進程的全局變量在另一個進程中都看不到,所以進程之間要交換數(shù)據(jù)必須通過內(nèi)核,在內(nèi)核中開辟一塊緩沖區(qū),進程A把數(shù)據(jù)從用戶空間拷到內(nèi)核緩沖區(qū),進程B再從內(nèi)核緩沖區(qū)把數(shù)據(jù)讀走,內(nèi)核提供的這種機制稱為進程間通信。

進程間通信的目的:

  • 傳輸數(shù)據(jù)。比如進程 A 負責生成數(shù)據(jù),進程 B 負責處理數(shù)據(jù),數(shù)據(jù)需要從 A 進程傳輸至 B 進程。
  • 共享資源。比如進程 A 與進程 B 共享某一塊內(nèi)存資源。
  • 模塊化。將系統(tǒng)功能劃分為多個進程模塊進行開發(fā),方便開發(fā)維護。
  • 加速計算。多核處理器環(huán)境,一個特定進程劃分為幾個進程并行運行。

Linux IPC(Inter-process Comminication, 進程間通信)的方式:

圖片

1、消息隊列

內(nèi)核中的一個優(yōu)先級隊列,多個進程通過訪問同一個隊列,進行添加結點或者獲取結點實現(xiàn)通信。

POSIX消息隊列頭文件:

#include < fcntl.h >           /* For O_* constants */
#include < sys/stat.h >        /* For mode constants */
#include < mqueue.h >

編譯鏈接需要加上 -lrt 鏈接。

消息隊列API接口

/**
 * @brief 創(chuàng)建消息隊列實例
 *
 * Detailed function description
 *
 * @param[in] name: 消息隊列名稱
 * @param[in] oflag:根據(jù)傳入標識來創(chuàng)建或者打開一個已創(chuàng)建的消息隊列
                    - O_CREAT: 創(chuàng)建一個消息隊列
                    - O_EXCL: 檢查消息隊列是否存在,一般與O_CREAT一起使用
                    - O_CREAT|O_EXCL: 消息隊列不存在則創(chuàng)建,已存在返回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:消息體緩沖區(qū)地址
 * @param[in] msg_len:消息體長度,長度必須大于等于消息屬性設定的最大值
 * @param[in] msg_prio:消息優(yōu)先級
 *
 * @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:消息體緩沖區(qū)地址
 * @param[in] msg_len:消息體長度,長度必須大于等于消息屬性設定的最大值
 * @param[in] msg_prio:消息優(yōu)先級
 * @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 無限阻塞方式發(fā)送消息
 *
 * Detailed function description
 *
 * @param[in] mqdes: 消息隊列描述符
 * @param[in] msg_ptr:待發(fā)送消息體緩沖區(qū)地址
 * @param[in] msg_len:消息體長度
 * @param[in] msg_prio:消息優(yōu)先級
 *
 * @return 成功返回0,失敗返回-1
 */
mqd_t mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio);

/**
 * @brief 指定超時時間阻塞方式發(fā)送消息
 *
 * Detailed function description
 *
 * @param[in] mqdes: 消息隊列描述符
 * @param[in] msg_ptr:待發(fā)送消息體緩沖區(qū)地址
 * @param[in] msg_len:消息體長度
 * @param[in] msg_prio:消息優(yōu)先級
 * @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接口使用例子:發(fā)送進程給接收進程發(fā)送測試數(shù)據(jù)。

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  ///< 最大消息數(shù)目

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;

    ///< 創(chuàng)建消息隊列
    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  ///< 最大消息數(shù)目

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、共享內(nèi)存

消息隊列的讀取和寫入的過程,會有發(fā)生用戶態(tài)與內(nèi)核態(tài)之間的消息拷貝過程。而共享內(nèi)存的方式則沒有這個拷貝過程,進程間通信速度較快。

在物理內(nèi)存上開辟一塊內(nèi)存空間,多個進程可以將同一塊物理內(nèi)存空間映射到自己的虛擬地址空間,通過自己的虛擬地址直接訪問這塊空間,通過這種方式實現(xiàn)數(shù)據(jù)共享。

圖片

POSIX共享內(nèi)存頭文件:

#include < sys/mman.h >
#include < sys/stat.h >
#include < unistd.h >

共享內(nèi)存API接口:

/**
 * @brief 創(chuàng)建共享內(nèi)存實例
 *
 * Detailed function description
 *
 * @param[in] name: 要打開或創(chuàng)建的共享內(nèi)存文件名
 * @param[in] oflag:打開的文件操作屬性
                    - O_CREAT: 創(chuàng)建一個共享內(nèi)存文件
                    - O_EXCL: 檢查共享內(nèi)存是否存在,一般與O_CREAT一起使用
                    - O_CREAT|O_EXCL: 共享內(nèi)存不存在則創(chuàng)建,已存在返回NULL
                    - O_NONBLOCK: 非阻塞模式打開,共享內(nèi)存不存在返回NULL
                    - O_RDONLY: 只讀模式打開
                    - O_WRONLY: 只寫模式打開
                    - O_RDWR: 讀寫模式打開
 * @param[in] mode:文件共享模式,例如 0777
 *
 * @return 成功返回共享內(nèi)存描述符,失敗返回-1,錯誤碼存于error中
 */
int shm_open(const char *name, int oflag, mode_t mode);

/**
 * @brief 刪除共享內(nèi)存
 *
 * Detailed function description
 *
 * @param[in] name: 創(chuàng)建的共享內(nèi)存文件名
 *
 * @return 成功返回0,失敗返回-1
 */
int shm_unlink(const char *name);

/**
 * @brief 將打開的文件映射到內(nèi)存
 *
 * Detailed function description
 *
 * @param[in] addr: 要將文件映射到的內(nèi)存地址,一般應該傳遞NULL來由Linux內(nèi)核指定
 * @param[in] length: 要映射的文件數(shù)據(jù)長度
 * @param[in] prot: 映射的內(nèi)存區(qū)域的操作權限(保護屬性),包括PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE
 * @param[in] flags: 標志位參數(shù),包括:MAP_SHARED、MAP_PRIVATE與MAP_ANONYMOUS。
 * @param[in] fd:  用來建立映射區(qū)的文件描述符,用 shm_open打開或者open打開的文件
 * @param[in] offset: 映射文件相對于文件頭的偏移位置,應該按4096字節(jié)對齊
 *
 * @return 成功返回0,失敗返回-1
 */
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
 
/**
 * @brief 取消內(nèi)存映射
 *
 * Detailed function description
 *
 * @param[in] addr: 由mmap成功返回的地址
 * @param[in] length: 要取消的內(nèi)存長度
 *
 * @return 成功返回0,失敗返回-1
 */
int munmap(void *addr, size_t length);

/**
 * @brief 將參數(shù)fd指定的文件大小改為參數(shù)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);

共享內(nèi)存基本API接口使用例子:發(fā)送進程給接收進程發(fā)送測試數(shù)據(jù)。

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;

    ///< 創(chuàng)建和讀端相同的文件標識
    int shm_fd = shm_open(SHM_NAME, O_RDWR | O_CREAT, 0666);
    if (shm_fd == -1) 
    {
        printf("shm_open error\\n");
    }

    ///< 設置共享內(nèi)存文件為8KB
    ftruncate(shm_fd , 8 * 1024);

    ///< 獲取共享內(nèi)存文件相關屬性信息
    struct stat filestat = {0};
    fstat(shm_fd, &filestat);
    printf("st_size = %ld\\n",filestat.st_size);

    ///< 內(nèi)存映射
    char *shm_ptr = (char*)mmap(NULL, filestat.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, shm_fd, 0);
    close(shm_fd);

    ///< 向共享內(nèi)存中寫入數(shù)據(jù)
    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)
{
    ///< 創(chuàng)建共享內(nèi)存文件標識符
    int shm_fd = shm_open(SHM_NAME, O_RDWR | O_CREAT, 0666);
    if (shm_fd == -1) 
    {
        printf("shm_open failed\\n");
        exit(EXIT_FAILURE);
    }

    ///< 設置共享內(nèi)存文件為8KB
    ftruncate(shm_fd , 8192);

    ///< 獲取共享內(nèi)存文件相關屬性信息
    struct stat filestat;
    fstat(shm_fd, &filestat);
    printf("st_size = %ld\\n",filestat.st_size);

    ///< 映射共享內(nèi)存,并獲取共享內(nèi)存的地址
    char *shm_ptr = (char*)mmap(NULL, filestat.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, shm_fd, 0);
    close(shm_fd);
    
    ///< 獲取共享內(nèi)存地址中的內(nèi)容并打印,最后再解除映射,刪除共享內(nèi)存
    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

圖片

對具有多個處理核系統(tǒng)消息傳遞的性能要優(yōu)于共享內(nèi)存。共享內(nèi)存會有高速緩存一致性問題,這是由共享數(shù)據(jù)在多個高速緩存之間遷移而引起的。隨著系統(tǒng)的處理核的數(shù)量的日益增加,可能導致消息傳遞作為 IPC 的首選機制。

3、socket

UNIX域套接字與傳統(tǒng)基于TCP/IP協(xié)議棧的socket不同,unix domain socket以文件系統(tǒng)作為地址空間,不需經(jīng)過TCP/IP的頭部封裝、報文ack確認、路由選擇、數(shù)據(jù)校驗與重傳過程,因此傳輸速率上也不會受網(wǎng)卡帶寬的限制。

unix domain socket在進程間通信同樣是基于“客戶端—服務器”(C-S)模式。

UNIX域套接字基本API接口使用例子:基于UNIX域套接字客戶端進程向服務端進程發(fā)送測試數(shù)據(jù)。

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)
{
 ///< 創(chuàng)建UNIX域字節(jié)流套接字
 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);
 }

 ///< 監(jiān)聽
 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)
{
 ///< 創(chuàng)建UNIX域字節(jié)流套接字
 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、管道

在內(nèi)核中開辟一塊緩沖區(qū);若多個進程拿到同一個管道(緩沖區(qū))的操作句柄,就可以訪問同一個緩沖區(qū),就可以進行通信。涉及到兩次用戶態(tài)與內(nèi)核態(tài)之間的數(shù)據(jù)拷貝。

(1)匿名管道

內(nèi)核中的緩沖區(qū)是沒有具體的標識符的,匿名管道只能用于具有親緣關系的進程間通信。

圖片

調用pipe接口可以創(chuàng)建一個匿名管道,并返回了兩個描述符,一個是管道的讀取端描述符 fd[0],另一個是管道的寫入端描述符 fd[1]。

管道是一個 半雙工通信 (可以選擇方向的單向傳輸)

匿名管道基本API接口使用例子:父進程通過管道發(fā)送測試數(shù)據(jù)給子進程。

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

int main()
{
    ///< 創(chuàng)建管道
 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] 用于從管道中讀取數(shù)據(jù)
    int write_fd = pipefd[1];  ///< pipefd[1] 用于向管道中寫入數(shù)據(jù)

    ///< 創(chuàng)建子進程
    pid_t pid = fork();
    if (pid == 0)
    {
        ///< 子進程從管道讀取數(shù)據(jù)  
  char buf[128] = {0};
  read(read_fd, buf, sizeof(buf));
        printf("child recv data from father: %s", buf);
 }
    else if (pid > 0)
   {
  ///< 父進程向管道寫入數(shù)據(jù)
        char *ptr = "hello88888888\\n";
        write(write_fd, ptr, strlen(ptr));
    }
 return 0;
}

編譯、運行:

圖片

如果需要雙向通信,則應該創(chuàng)建兩個管道。

(2)命名管道

命名管道也是內(nèi)核中的一塊緩沖區(qū),并且這個緩沖區(qū)具有標識符;這個標識符是一個可見于文件系統(tǒng)的管道文件,能夠被其他進程找到并打開管道文件,則可以獲取管道的操作句柄,所以該命名管道可用于同一主機上的任意進程間通信。

創(chuàng)建命名管道的接口:

int mkfifo(const char *pathname, mode_t mode);

命名管道基本API接口使用例子:一個進程往管道中寫入測試數(shù)據(jù),另一個進程從管道中讀取數(shù)據(jù)。

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)
{
    ///< 創(chuàng)建管道文件
    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);
    ///< 創(chuàng)建管道文件
    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)是進程和線程間同步的一種機制。

信號量本質是一個非負的整型變量。增加一個可用資源執(zhí)行加一,也稱為V操作;獲取一個資源資源后執(zhí)行減一,也稱為P操作。

信號量根據(jù)信號值不同可分為兩類:

  • 二值信號量,信號量值只有0和1,初始值為1,1表示資源可用,0表示資源不可用;二值信號量與互斥鎖類似。
  • 計數(shù)信號量, 信號量的值在0到一個大于1的限制值之間,信號值表示可用的資源的數(shù)目。

信號量根據(jù)作用對象不同可分為兩類:

  • 有名信號量,信號值保存在文件中,用于進程間同步
  • 無名信號量,又稱為基于內(nèi)存信號量,信號值保存在內(nèi)存中,用于線程間同步

POSIX信號量頭文件:

#include < semaphore.h >

編譯鏈接需要加-lpthread參數(shù)。

信號量API接口:

/**
 * @brief 創(chuàng)建信號量
 *
 * 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: 信號量作用域,分為進程內(nèi)作用域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: 超時時間,單位為時鐘節(jié)拍
 *
 * @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 產(chǎn)生信號量
 *
 * 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;

    ///< 創(chuàng)建信號量
    sem_t *sem = sem_open(SEM_NAME, O_CREAT, 0666, 1);
    if (NULL == sem)
    {
       printf("sem_open error\\n");
       exit(EXIT_FAILURE); 
    }

    ///< 創(chuàng)建子進程
    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)
    {
        ///< 父進程執(zhí)行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總結

操作系統(tǒng)根據(jù)不同的場景提供了不同的方式,消息隊列、共享內(nèi)存、UNIX域套接字、管道、信號量。

消息隊列: 內(nèi)核中的一個優(yōu)先級隊列,多個進程通過訪問同一個隊列,在隊列當中添加或者獲取節(jié)點來實現(xiàn)進程間通信。

共享內(nèi)存: 本質是一塊物理內(nèi)存,多個進程將同一塊物理內(nèi)存映射到自己的虛擬地址空間中,再通過頁表映射到物理地址達到進程間通信,它是最快的進程間通信方式,相較其他通信方式少了兩步數(shù)據(jù)拷貝操作。

UNIX域套接字: 與TCP/IP套接字使用方式相同,但UNIX域套接字以文件系統(tǒng)作為地址空間,不需經(jīng)過TCP/IP的頭部封裝、報文ack確認、路由選擇、數(shù)據(jù)校驗與重傳過程,因此傳輸速率上也不會受網(wǎng)卡帶寬的限制。

管道: 內(nèi)核中的一塊緩沖區(qū),分為匿名管道和命名管道。匿名管道只能用于具有親緣關系的進程間;而命名管道可用于同一主機上任意進程間通信。

信號量: 本質是內(nèi)核中的一個計數(shù)器,主要實現(xiàn)進程間的同步與互斥,對資源進行計數(shù),有兩種操作,分別是在訪問資源之前進行的p操作,還有產(chǎn)生資源之后的v操作。

聲明:本文內(nèi)容及配圖由入駐作者撰寫或者入駐合作網(wǎng)站授權轉載。文章觀點僅代表作者本人,不代表電子發(fā)燒友網(wǎng)立場。文章及其配圖僅供工程師學習之用,如有內(nèi)容侵權或者其他違規(guī)問題,請聯(lián)系本站處理。 舉報投訴
  • 內(nèi)存
    +關注

    關注

    8

    文章

    3025

    瀏覽量

    74054
  • 程序
    +關注

    關注

    117

    文章

    3787

    瀏覽量

    81049
  • 線程
    +關注

    關注

    0

    文章

    504

    瀏覽量

    19684
收藏 人收藏

    評論

    相關推薦

    Linux中進程線程的深度對比

    關于進程線程,在 Linux 中是一對兒很核心的概念。但是進程線程到底有啥聯(lián)系,又有啥區(qū)別,很多人還都沒有搞清楚。
    發(fā)表于 10-14 16:47 ?1309次閱讀
    Linux<b class='flag-5'>中進程</b>和<b class='flag-5'>線程</b>的深度對比

    進程線程區(qū)別

    系統(tǒng)對應用的并發(fā)性。進程線程區(qū)別在于:簡而言之,一個程序至少有一個進程,一個進程至少有一個
    發(fā)表于 12-12 09:28

    進程線程區(qū)別

    `1、進程線程區(qū)別和聯(lián)系進程(process)和線程(thread)是操作系統(tǒng)的基本概念,但是它們比較抽象,不容易掌握。計算機的核心是C
    發(fā)表于 11-30 14:06

    線程、進程程序區(qū)別

    程序中同時運行多個線程完成不同的工作,稱為多線程。線程進程區(qū)別在于,子
    發(fā)表于 03-23 13:09

    進程線程區(qū)別在哪?

    1、進程線程區(qū)別:1. 線程程序執(zhí)行的最小單位,而進程是操作系統(tǒng)分配資源的最小單位;2. 一
    發(fā)表于 07-07 06:53

    線程進程有哪些區(qū)別?

    線程進程區(qū)別在于,子進程和父進程有不同的代碼和數(shù)據(jù)空間,而多個線程則共享數(shù)據(jù)空間,每個
    發(fā)表于 07-20 07:48 ?1971次閱讀
    <b class='flag-5'>線程</b>與<b class='flag-5'>進程</b>有哪些<b class='flag-5'>區(qū)別</b>?

    線程進程區(qū)別和聯(lián)系,線程進程通信方式

    摘要:進程線程都是計算里的兩項執(zhí)行活動,各有特色和優(yōu)勢。下面就來介紹線程進程之間的區(qū)別聯(lián)系以及通信方式。
    發(fā)表于 12-08 14:12 ?1.3w次閱讀

    一文讀懂線程、進程、程序之間的不同

    線程進程區(qū)別在于,子進程和父進程有不同的代碼和數(shù)據(jù)空間,而多個線程則共享數(shù)據(jù)空間,每個
    發(fā)表于 03-12 08:48 ?1343次閱讀
    一文讀懂<b class='flag-5'>線程</b>、<b class='flag-5'>進程</b>、<b class='flag-5'>程序</b>之間的不同

    線程進程的關系與區(qū)別

    線程是CPU調度的最小單位(程序執(zhí)行流的最小單元),它被包含在進程之中,是進程中的實際運作單元。一條線程
    的頭像 發(fā)表于 11-29 11:01 ?1.4w次閱讀

    進程線程分別是什么,它們的區(qū)別是什么

    程和線程區(qū)別是什么?有什么關系?相信大家對于進程都很熟悉了吧,而線程相對于進程而言,是一個更加接近于執(zhí)行體的概念,為了讓大家更好的了解
    發(fā)表于 03-24 17:26 ?9390次閱讀
    <b class='flag-5'>進程</b>和<b class='flag-5'>線程</b>分別是什么,它們的<b class='flag-5'>區(qū)別</b>是什么

    進程切換與線程切換有啥區(qū)別

    注意這個題目問的是進程**切換**與線程**切換**的區(qū)別,不是進程線程區(qū)別。當然這里的**
    的頭像 發(fā)表于 02-24 14:16 ?586次閱讀

    進程線程區(qū)別

    每個進程都有獨立的代碼和數(shù)據(jù)空間(程序上下文),程序之間的切換會有較大的開銷;線程可以看做輕量級的進程,同一類
    的頭像 發(fā)表于 05-09 11:06 ?6027次閱讀
    <b class='flag-5'>進程</b>和<b class='flag-5'>線程</b>的<b class='flag-5'>區(qū)別</b>

    進程線程區(qū)別以及優(yōu)缺點

    進程線程 1、什么是進程線程,有什么區(qū)別? 進程是資源(CPU、內(nèi)存等)分配的基本單位,
    的頭像 發(fā)表于 07-21 11:02 ?1381次閱讀

    mcu線程進程區(qū)別是什么

    MCU線程進程是嵌入式系統(tǒng)中常見的并行執(zhí)行的概念,它們之間有許多區(qū)別,包括線程進程的定義、資源管理、通信機制、執(zhí)行方式等等。下面將詳細介
    的頭像 發(fā)表于 01-04 10:45 ?754次閱讀

    線程是什么的基本單位 進程線程的本質區(qū)別

    線程是操作系統(tǒng)中處理器調度的基本單位,它代表著獨立的執(zhí)行流。在一個進程中,可以包含多個線程,這些線程共享相同的進程資源,如內(nèi)存空間、文件描述
    的頭像 發(fā)表于 02-02 16:30 ?935次閱讀