c语言多线程如何通信

C语言多线程通信的方式有：共享内存、信号量、消息队列、管道、socket。其中，共享内存是一种高效的通信方式，适用于同一进程内的线程间通信。下面详细介绍共享内存的实现方法。

一、共享内存

共享内存是一种高效的进程间通信方式。多线程可以通过访问同一块内存区域进行通信。在C语言中，可以通过pthread库来实现多线程，并利用全局变量或动态分配的内存进行共享。

1.1、创建线程

在C语言中，可以使用pthread_create函数来创建线程。该函数需要传递线程ID、线程属性、线程函数以及线程函数参数。

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
void* thread_function(void* arg) {
    int* shared_data = (int*)arg;
    printf("Thread: Shared data is %dn", *shared_data);
    return NULL;
}
int main() {
    pthread_t thread;
    int shared_data = 42;
    if (pthread_create(&thread, NULL, thread_function, &shared_data)) {
        fprintf(stderr, "Error creating threadn");
        return 1;
    }
    if (pthread_join(thread, NULL)) {
        fprintf(stderr, "Error joining threadn");
        return 2;
    }
    return 0;
}

1.2、同步访问

为了防止线程竞争条件，通常需要使用同步机制，例如互斥锁（mutex）。在C语言中，可以使用pthread_mutex_t类型的变量来实现互斥锁。

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
pthread_mutex_t lock;
void* thread_function(void* arg) {
    int* shared_data = (int*)arg;
    pthread_mutex_lock(&lock);
    (*shared_data)++;
    printf("Thread: Shared data is %dn", *shared_data);
    pthread_mutex_unlock(&lock);
    return NULL;
}
int main() {
    pthread_t thread;
    int shared_data = 42;
    pthread_mutex_init(&lock, NULL);
    if (pthread_create(&thread, NULL, thread_function, &shared_data)) {
        fprintf(stderr, "Error creating threadn");
        return 1;
    }
    pthread_mutex_lock(&lock);
    shared_data++;
    pthread_mutex_unlock(&lock);
    if (pthread_join(thread, NULL)) {
        fprintf(stderr, "Error joining threadn");
        return 2;
    }
    pthread_mutex_destroy(&lock);
    return 0;
}

二、信号量

信号量是一种用于控制访问共享资源的同步机制。与互斥锁不同，信号量可以允许多个线程访问同一资源，但需要控制访问数量。在C语言中，可以使用sem_t类型的变量来实现信号量。

2.1、初始化信号量

在使用信号量之前，需要初始化信号量。可以使用sem_init函数来初始化信号量。

#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
sem_t semaphore;
void* thread_function(void* arg) {
    int* shared_data = (int*)arg;
    sem_wait(&semaphore);
    (*shared_data)++;
    printf("Thread: Shared data is %dn", *shared_data);
    sem_post(&semaphore);
    return NULL;
}
int main() {
    pthread_t thread;
    int shared_data = 42;
    sem_init(&semaphore, 0, 1);
    if (pthread_create(&thread, NULL, thread_function, &shared_data)) {
        fprintf(stderr, "Error creating threadn");
        return 1;
    }
    sem_wait(&semaphore);
    shared_data++;
    sem_post(&semaphore);
    if (pthread_join(thread, NULL)) {
        fprintf(stderr, "Error joining threadn");
        return 2;
    }
    sem_destroy(&semaphore);
    return 0;
}

三、消息队列

消息队列是一种用于在线程之间传递消息的数据结构。消息队列可以保证消息的顺序性，并且可以实现线程之间的异步通信。在C语言中，可以使用sys/msg.h库来实现消息队列。

3.1、创建和发送消息

可以使用msgget函数来创建消息队列，使用msgsnd函数来发送消息。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct message {
    long msg_type;
    char msg_text[100];
};
int main() {
    key_t key;
    int msgid;
    struct message msg;
    key = ftok("progfile", 65);
    msgid = msgget(key, 0666 | IPC_CREAT);
    msg.msg_type = 1;
    strcpy(msg.msg_text, "Hello");
    msgsnd(msgid, &msg, sizeof(msg), 0);
    printf("Message sent: %sn", msg.msg_text);
    return 0;
}

3.2、接收消息

可以使用msgrcv函数来接收消息。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct message {
    long msg_type;
    char msg_text[100];
};
int main() {
    key_t key;
    int msgid;
    struct message msg;
    key = ftok("progfile", 65);
    msgid = msgget(key, 0666 | IPC_CREAT);
    msgrcv(msgid, &msg, sizeof(msg), 1, 0);
    printf("Message received: %sn", msg.msg_text);
    msgctl(msgid, IPC_RMID, NULL);
    return 0;
}

四、管道

管道是一种用于在进程之间传递数据的通信机制。在C语言中，可以使用pipe函数来创建管道，并使用read和write函数来进行数据传输。

4.1、创建管道

可以使用pipe函数来创建管道。该函数会创建两个文件描述符，一个用于读，一个用于写。

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
    int pipefd[2];
    char buffer[128];
    pid_t pid;
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }
    if (pid == 0) {
        close(pipefd[1]);
        read(pipefd[0], buffer, sizeof(buffer));
        printf("Child received: %sn", buffer);
        close(pipefd[0]);
    } else {
        close(pipefd[0]);
        write(pipefd[1], "Hello from parent", 17);
        close(pipefd[1]);
    }
    return 0;
}

五、Socket

Socket是一种用于网络通信的机制，可以在不同主机之间进行数据传输。在C语言中，可以使用socket库来实现Socket通信。

5.1、创建和连接Socket

可以使用socket函数来创建Socket，并使用connect函数来连接到服务器。

#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
int main() {
    int sock;
    struct sockaddr_in server;
    char message[100], server_reply[2000];
    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == -1) {
        printf("Could not create socket");
    }
    printf("Socket createdn");
    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    server.sin_family = AF_INET;
    server.sin_port = htons(8888);
    if (connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0) {
        perror("connect failed. Error");
        return 1;
    }
    printf("Connectedn");
    strcpy(message, "Hello Server");
    if (send(sock, message, strlen(message), 0) < 0) {
        printf("Send failed");
        return 1;
    }
    printf("Data sentn");
    if (recv(sock, server_reply, 2000, 0) < 0) {
        printf("recv failed");
        return 1;
    }
    printf("Reply received: %sn", server_reply);
    close(sock);
    return 0;
}

5.2、服务器端实现

服务器端需要创建一个监听Socket，并接受客户端的连接请求。

#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
int main() {
    int socket_desc, client_sock, c;
    struct sockaddr_in server, client;
    char client_message[2000];
    socket_desc = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_desc == -1) {
        printf("Could not create socket");
    }
    printf("Socket createdn");
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons(8888);
    if (bind(socket_desc, (struct sockaddr*)&server, sizeof(server)) < 0) {
        perror("bind failed. Error");
        return 1;
    }
    printf("Bind donen");
    listen(socket_desc, 3);
    printf("Waiting for incoming connections...n");
    c = sizeof(struct sockaddr_in);
    client_sock = accept(socket_desc, (struct sockaddr*)&client, (socklen_t*)&c);
    if (client_sock < 0) {
        perror("accept failed");
        return 1;
    }
    printf("Connection acceptedn");
    if (recv(client_sock, client_message, 2000, 0) < 0) {
        printf("recv failed");
        return 1;
    }
    printf("Client message: %sn", client_message);
    char* message = "Hello Client";
    write(client_sock, message, strlen(message));
    close(client_sock);
    close(socket_desc);
    return 0;
}

六、总结

在C语言中，多线程通信的方式有多种选择，包括共享内存、信号量、消息队列、管道和Socket。每种方式都有其优缺点和适用场景。在实际开发中，可以根据具体需求选择合适的通信方式。对于需要高效和同步访问的场景，共享内存和信号量是不错的选择；而对于需要异步通信和顺序性保证的场景，消息队列和管道则更为适用；Socket则适用于网络通信的场景。无论选择哪种方式，都需要注意线程安全和同步问题，以确保通信的正确性和可靠性。

推荐使用研发项目管理系统PingCode和通用项目管理软件Worktile来管理您的项目，提升团队协作效率和项目管理水平。