正文

Linux系统下高效线程间通信方法全解析

/0 浏览量
0710

在多线程编程中，线程间通信是确保程序正确性和效率的关键。Linux系统提供了多种线程间通信的方法，每种方法都有其特点和适用场景。本文将全面解析Linux系统下高效线程间通信的方法。

1. 管道（Pipes）

管道是Linux系统中最早期的线程间通信机制之一。它允许一个进程向另一个进程发送数据，但只能有一个进程读取，另一个进程写入。

1.1 管道类型

  • 无名管道：用于具有亲缘关系的进程间通信，如父子进程。
  • 命名管道：允许无关的进程进行通信，具有命名空间。

1.2 代码示例

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

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

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

    if (cpid == 0) { // 子进程
        close(pipefd[1]); // 关闭写端
        dup2(pipefd[0], STDIN_FILENO); // 将标准输入重定向到管道
        execlp("wc", "wc", "-l", NULL);
        perror("execlp");
        exit(EXIT_FAILURE);
    } else { // 父进程
        close(pipefd[0]); // 关闭读端
        write(pipefd[1], "Hello, World!\n", 15);
        close(pipefd[1]); // 关闭写端
        wait(NULL);
    }

    return 0;
}

2. 套接字（Sockets）

套接字是一种更为通用的通信机制，可以用于不同主机间的进程通信。

2.1 套接字类型

  • 流式套接字：提供可靠的数据传输，如TCP。
  • 数据报套接字：提供无连接的数据传输，如UDP。

2.2 代码示例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
    int sockfd;
    struct sockaddr_in servaddr;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(8080);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    listen(sockfd, 10);

    int connfd;
    struct sockaddr_in cliaddr;
    socklen_t len = sizeof(cliaddr);

    connfd = accept(sockfd, (struct sockaddr *)&cliaddr, &len);
    char msg[] = "Hello, World!";
    send(connfd, msg, strlen(msg), 0);
    close(connfd);
    close(sockfd);

    return 0;
}

3. 信号量（Semaphores）

信号量是一种用于同步多个进程或线程访问共享资源的机制。

3.1 信号量类型

  • 二进制信号量：只能取0或1的值，用于互斥锁。
  • 计数信号量：可取任意非负整数值，用于资源管理。

3.2 代码示例

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

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void *thread_func(void *arg) {
    pthread_mutex_lock(&lock);
    printf("Thread %ld entered the critical section.\n", (long)arg);
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    pthread_t threads[10];
    for (long i = 0; i < 10; i++) {
        pthread_create(&threads[i], NULL, thread_func, (void *)i);
    }
    for (long i = 0; i < 10; i++) {
        pthread_join(threads[i], NULL);
    }
    pthread_mutex_destroy(&lock);
    return 0;
}

4. 条件变量（Condition Variables）

条件变量用于线程间的同步，允许线程在某些条件不满足时等待，直到其他线程通知条件成立。

4.1 代码示例

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

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void *thread_func(void *arg) {
    pthread_mutex_lock(&lock);
    printf("Thread %ld is waiting for the condition.\n", (long)arg);
    pthread_cond_wait(&cond, &lock);
    printf("Thread %ld has been notified.\n", (long)arg);
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    pthread_t threads[10];
    for (long i = 0; i < 10; i++) {
        pthread_create(&threads[i], NULL, thread_func, (void *)i);
    }
    pthread_cond_signal(&cond);
    for (long i = 0; i < 10; i++) {
        pthread_join(threads[i], NULL);
    }
    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&cond);
    return 0;
}

5. 共享内存（Shared Memory）

共享内存允许多个进程或线程共享同一块内存区域，从而实现高效的通信。

5.1 代码示例

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <pthread.h>

#define SHM_SIZE 1024

int main() {
    int shmid;
    char *shm, *s;

    shmid = shm_open("/my_shm", O_CREAT | O_RDWR, 0666);
    ftruncate(shmid, SHM_SIZE);
    shm = mmap(0, SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, shmid, 0);
    close(shmid);

    pthread_t thread_id;
    pthread_create(&thread_id, NULL, (void *)write_to_shm, shm);
    pthread_create(&thread_id, NULL, (void *)read_from_shm, shm);

    pthread_join(thread_id, NULL);
    pthread_join(thread_id, NULL);

    munmap(shm, SHM_SIZE);
    shm_unlink("/my_shm");

    return 0;
}

总结

Linux系统提供了多种高效的线程间通信方法，包括管道、套接字、信号量、条件变量和共享内存。根据具体需求和场景选择合适的方法，可以有效地提高程序的性能和可靠性。

-- 展开阅读全文 --