正文

掌握进程与线程通信技巧，提高程序效率与稳定性

/0 浏览量
0524

在多线程或多进程编程中，进程与线程之间的通信是确保程序高效运行和稳定性的关键。有效的通信机制不仅能提高程序的执行效率，还能避免因数据不一致导致的错误。以下是一些实用的进程与线程通信技巧。

1. 使用互斥锁（Mutex）

互斥锁是一种常用的同步机制，用于保护共享资源，防止多个线程同时访问同一资源。在C++中，可以使用std::mutex来实现互斥锁。

#include <mutex>

std::mutex mtx;

void print_block(int n, char c) {
    mtx.lock();
    //临界区
    for (int i = 0; i < n; ++i) {
        std::cout << c << ' ';
    }
    std::cout << '\n';
    mtx.unlock();
}

2. 条件变量（Condition Variable）

条件变量用于线程间的同步，可以让一个或多个线程等待某个条件成立。在C++中，可以使用std::condition_variable来实现条件变量。

#include <condition_variable>
#include <thread>
#include <mutex>
#include <iostream>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void wait_for_condition() {
    std::unique_lock<std::mutex> lck(mtx);
    cv.wait(lck, []{ return ready; });
    std::cout << "Condition is true\n";
}

void set_condition() {
    std::unique_lock<std::mutex> lck(mtx);
    ready = true;
    cv.notify_one();
}

3. 管道（Pipe）

管道是一种用于进程间通信的机制。在Linux系统中，可以使用pipe()函数创建管道，并通过read()和write()函数进行读写操作。

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

int main() {
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    pid_t cpid;
    cpid = fork();
    if (cpid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (cpid == 0) { // 子进程
        close(pipefd[1]); // 关闭管道的写端
        dup2(pipefd[0], STDIN_FILENO); // 将管道的读端复制到标准输入
        execlp("grep", "grep", "grep", (char *) NULL);
        perror("execlp");
        exit(EXIT_FAILURE);
    } else { // 父进程
        close(pipefd[0]); // 关闭管道的读端
        write(pipefd[1], "test\n", 5);
        close(pipefd[1]);
    }

    return 0;
}

4. 信号量（Semaphore）

信号量是一种用于控制对共享资源的访问的同步机制。在C++中，可以使用std::semaphore来实现信号量。

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

sem_t sem;

void *thread_func(void *arg) {
    sem_wait(&sem); // P操作
    printf("Thread %ld is running\n", (long)arg);
    sleep(1);
    sem_post(&sem); // V操作
    return NULL;
}

int main() {
    pthread_t threads[5];
    long i;
    sem_init(&sem, 0, 5); // 初始化信号量为5

    for (i = 0; i < 5; i++) {
        pthread_create(&threads[i], NULL, thread_func, (void *)i);
    }

    for (i = 0; i < 5; i++) {
        pthread_join(threads[i], NULL);
    }

    sem_destroy(&sem); // 销毁信号量
    return 0;
}

5. 使用消息队列（Message Queue）

消息队列是一种用于进程间通信的机制，允许一个或多个进程发送和接收消息。在Linux系统中，可以使用msgget()、msgsend()和msgrcv()等函数来实现消息队列。

#include <sys/ipc.h>
#include <sys/msg.h>

struct msgbuf {
    long msgtype;
    char msgtext[100];
};

int main() {
    key_t key = 1234;
    int msgid = msgget(key, 0666 | IPC_CREAT);
    struct msgbuf msg;

    msg.msgtype = 1;
    snprintf(msg.msgtext, sizeof(msg.msgtext), "Hello, world!");

    msgsnd(msgid, &msg, sizeof(msg.msgtext), 0);

    msg.msgtype = 2;
    snprintf(msg.msgtext, sizeof(msg.msgtext), "Goodbye, world!");

    msgrcv(msgid, &msg, sizeof(msg.msgtext), 2, 0);

    msgctl(msgid, IPC_RMID, NULL); // 删除消息队列
    return 0;
}

通过以上技巧，您可以更好地掌握进程与线程通信，提高程序效率与稳定性。在实际编程过程中，请根据具体需求选择合适的通信机制。

-- 展开阅读全文 --