C语言多线程编程与POSIX线程模型实战
2023-09-093.4k 阅读
多线程编程基础
在深入探讨C语言的多线程编程和POSIX线程模型之前，我们先来了解一些多线程编程的基础概念。
什么是线程
线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个进程可以包含多个线程，这些线程共享进程的大部分资源，例如地址空间、文件描述符等，但每个线程都有自己独立的栈空间，用于存储局部变量和函数调用的上下文。
与进程相比，线程的创建和销毁开销更小，线程之间的切换也比进程之间的切换更高效。这使得多线程编程在提高程序的并发性能方面具有很大的优势。例如，在一个网络服务器程序中，可以为每个客户端连接分配一个线程来处理，这样服务器就可以同时处理多个客户端的请求，提高系统的整体吞吐量。
多线程编程的优势与挑战
-
优势
- 提高并发性能：如前文所述，多线程能够让程序在同一时间内处理多个任务，充分利用多核CPU的性能，提升整体的执行效率。例如，在图像处理软件中，可以使用一个线程进行图像的渲染，另一个线程处理用户的交互操作，从而提高用户体验。
- 资源共享：线程共享进程的资源，这意味着在线程之间传递数据相对容易，不需要像进程间通信那样采用复杂的机制，降低了编程的复杂度。
- 响应性更好：对于一些需要长时间运行的任务，使用多线程可以将其放到后台线程中执行，而主线程仍然可以响应用户的输入，避免程序出现假死的情况。比如在文件下载程序中，下载任务可以在后台线程执行，而主线程继续处理用户界面的操作。
-
挑战
- 线程安全问题：由于多个线程共享进程的资源，当多个线程同时访问和修改共享数据时，可能会导致数据不一致的问题。例如，两个线程同时对一个全局变量进行自增操作，如果没有适当的同步机制，最终的结果可能并不是预期的自增两次。
- 死锁：当两个或多个线程相互等待对方释放资源时，就会发生死锁。例如，线程A持有资源1并等待资源2，而线程B持有资源2并等待资源1，这样两个线程就会永远等待下去，导致程序无法继续执行。
- 调试困难：多线程程序的执行顺序是不确定的，这使得调试变得更加困难。很难重现问题，因为每次运行程序时，线程的执行顺序可能不同，错误可能时隐时现。
POSIX线程模型概述
POSIX（Portable Operating System Interface）线程是一种符合POSIX标准的线程模型，它提供了一套API用于在C语言中进行多线程编程。POSIX线程模型在类Unix系统（如Linux、FreeBSD等）上广泛使用，并且也有一些在Windows系统上的实现（如通过MinGW等工具）。
POSIX线程库的特点
- 可移植性：POSIX线程模型的设计目标之一就是实现跨平台的可移植性。通过遵循POSIX标准，编写的多线程程序可以在不同的类Unix系统上运行，而无需进行大量的修改。这使得开发人员可以在不同的操作系统环境中复用代码，降低开发成本。
- 丰富的API：POSIX线程库提供了丰富的API，涵盖了线程的创建、销毁、同步等各个方面。这些API设计简洁明了，易于学习和使用。例如，
pthread_create函数用于创建一个新的线程，pthread_join函数用于等待一个线程结束，通过这些函数，开发人员可以方便地控制线程的生命周期。 - 与操作系统紧密结合：POSIX线程模型与底层操作系统紧密结合，能够充分利用操作系统提供的线程管理和调度机制。这使得POSIX线程在性能上能够达到较高的水平，并且能够适应不同操作系统的特性。
POSIX线程库的安装与引入
在类Unix系统中，POSIX线程库通常是系统自带的，无需额外安装。在编写C语言程序时，只需要在代码中引入<pthread.h>头文件即可使用POSIX线程库的功能。例如：
#include <pthread.h>
#include <stdio.h>
// 线程执行函数
void* thread_function(void* arg) {
printf("This is a thread.\n");
return NULL;
}
int main() {
pthread_t thread;
// 创建线程
if (pthread_create(&thread, NULL, thread_function, NULL) != 0) {
printf("\n ERROR creating thread");
return 1;
}
// 等待线程结束
if (pthread_join(thread, NULL) != 0) {
printf("\n ERROR joining thread");
return 2;
}
printf("Thread joined.\n");
return 0;
}
在上述代码中，我们首先引入了<pthread.h>头文件，然后定义了一个线程执行函数thread_function。在main函数中，我们使用pthread_create函数创建了一个新的线程，并使用pthread_join函数等待该线程结束。编译这段代码时，需要链接pthread库，例如在Linux系统上可以使用以下命令编译：gcc -o test test.c -lpthread。
C语言中使用POSIX线程进行多线程编程
线程的创建与终止
- 线程的创建
pthread_create函数：在POSIX线程模型中，使用pthread_create函数来创建一个新的线程。其函数原型如下：
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
thread参数是一个指向pthread_t类型变量的指针，用于存储新创建线程的标识符。attr参数用于指定线程的属性，如果为NULL，则使用默认属性。start_routine是一个函数指针，指向线程要执行的函数，该函数接受一个void*类型的参数并返回一个void*类型的值。arg是传递给start_routine函数的参数。
例如，我们创建一个简单的线程，该线程输出一条消息：
#include <pthread.h>
#include <stdio.h>
// 线程执行函数
void* print_message(void* msg) {
printf("%s\n", (char*)msg);
return NULL;
}
int main() {
pthread_t thread;
char message[] = "Hello from thread!";
// 创建线程
if (pthread_create(&thread, NULL, print_message, (void*)message) != 0) {
printf("\n ERROR creating thread");
return 1;
}
printf("Thread created.\n");
// 等待线程结束
if (pthread_join(thread, NULL) != 0) {
printf("\n ERROR joining thread");
return 2;
}
printf("Thread joined.\n");
return 0;
}
在上述代码中，print_message函数是线程要执行的函数，message字符串作为参数传递给该函数。通过pthread_create函数创建线程后，主线程会继续执行后续代码，直到调用pthread_join函数等待线程结束。
- 线程的终止
- 线程主动终止：线程可以通过调用
pthread_exit函数来主动终止自身。其函数原型为：
- 线程主动终止：线程可以通过调用
void pthread_exit(void *retval);
retval参数是线程的返回值，可以通过pthread_join函数获取。例如，我们修改前面的代码，让线程在输出消息后主动终止：
#include <pthread.h>
#include <stdio.h>
// 线程执行函数
void* print_message(void* msg) {
printf("%s\n", (char*)msg);
pthread_exit(NULL);
}
int main() {
pthread_t thread;
char message[] = "Hello from thread!";
// 创建线程
if (pthread_create(&thread, NULL, print_message, (void*)message) != 0) {
printf("\n ERROR creating thread");
return 1;
}
printf("Thread created.\n");
// 等待线程结束
if (pthread_join(thread, NULL) != 0) {
printf("\n ERROR joining thread");
return 2;
}
printf("Thread joined.\n");
return 0;
}
- **其他线程终止指定线程**：一个线程可以通过调用`pthread_cancel`函数来请求终止另一个线程。其函数原型为：
int pthread_cancel(pthread_t thread);
但是，被请求终止的线程不一定会立即终止，它需要在运行过程中检测取消请求，并进行相应的处理。被取消的线程可以通过设置取消点（如调用pthread_testcancel函数）来响应取消请求。例如：
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
// 线程执行函数
void* thread_function(void* arg) {
while (1) {
printf("Thread is running...\n");
// 设置取消点
pthread_testcancel();
sleep(1);
}
return NULL;
}
int main() {
pthread_t thread;
// 创建线程
if (pthread_create(&thread, NULL, thread_function, NULL) != 0) {
printf("\n ERROR creating thread");
return 1;
}
printf("Thread created.\n");
// 主线程睡眠3秒后取消线程
sleep(3);
if (pthread_cancel(thread) != 0) {
printf("\n ERROR canceling thread");
return 2;
}
// 等待线程结束
if (pthread_join(thread, NULL) != 0) {
printf("\n ERROR joining thread");
return 3;
}
printf("Thread joined.\n");
return 0;
}
在上述代码中，thread_function函数中通过pthread_testcancel设置了取消点，主线程在创建线程3秒后调用pthread_cancel请求取消线程。
线程同步
- 互斥锁（Mutex）
- 原理：互斥锁是一种最简单的线程同步机制，它用于保证在同一时间只有一个线程能够访问共享资源。互斥锁就像是一把锁，当一个线程获取了锁（即锁定互斥锁），其他线程就必须等待，直到该线程释放锁（即解锁互斥锁）。
- 相关函数：
pthread_mutex_init函数：用于初始化一个互斥锁。其函数原型为：
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
mutex参数是指向要初始化的互斥锁变量的指针，attr参数用于指定互斥锁的属性，如果为NULL，则使用默认属性。
- pthread_mutex_lock函数：用于锁定互斥锁。如果互斥锁已经被其他线程锁定，调用该函数的线程将被阻塞，直到互斥锁可用。其函数原型为：
int pthread_mutex_lock(pthread_mutex_t *mutex);
- **`pthread_mutex_unlock`函数**：用于解锁互斥锁，使其他线程可以获取该互斥锁。其函数原型为：
int pthread_mutex_unlock(pthread_mutex_t *mutex);
- **`pthread_mutex_destroy`函数**：用于销毁一个互斥锁，释放相关资源。其函数原型为：
int pthread_mutex_destroy(pthread_mutex_t *mutex);
- **示例代码**：下面是一个使用互斥锁来保护共享资源的示例，假设有两个线程同时对一个全局变量进行自增操作：
#include <pthread.h>
#include <stdio.h>
// 共享变量
int shared_variable = 0;
// 互斥锁
pthread_mutex_t mutex;
// 线程执行函数1
void* increment1(void* arg) {
for (int i = 0; i < 1000000; i++) {
// 锁定互斥锁
pthread_mutex_lock(&mutex);
shared_variable++;
// 解锁互斥锁
pthread_mutex_unlock(&mutex);
}
return NULL;
}
// 线程执行函数2
void* increment2(void* arg) {
for (int i = 0; i < 1000000; i++) {
// 锁定互斥锁
pthread_mutex_lock(&mutex);
shared_variable++;
// 解锁互斥锁
pthread_mutex_unlock(&mutex);
}
return NULL;
}
int main() {
pthread_t thread1, thread2;
// 初始化互斥锁
if (pthread_mutex_init(&mutex, NULL) != 0) {
printf("\n ERROR initializing mutex");
return 1;
}
// 创建线程1
if (pthread_create(&thread1, NULL, increment1, NULL) != 0) {
printf("\n ERROR creating thread1");
return 2;
}
// 创建线程2
if (pthread_create(&thread2, NULL, increment2, NULL) != 0) {
printf("\n ERROR creating thread2");
return 3;
}
// 等待线程1结束
if (pthread_join(thread1, NULL) != 0) {
printf("\n ERROR joining thread1");
return 4;
}
// 等待线程2结束
if (pthread_join(thread2, NULL) != 0) {
printf("\n ERROR joining thread2");
return 5;
}
printf("Shared variable value: %d\n", shared_variable);
// 销毁互斥锁
if (pthread_mutex_destroy(&mutex) != 0) {
printf("\n ERROR destroying mutex");
return 6;
}
return 0;
}
在上述代码中，通过互斥锁mutex保护了shared_variable的自增操作，确保每次只有一个线程能够对其进行修改，从而避免了数据竞争问题。
- 条件变量（Condition Variable）
- 原理：条件变量用于线程之间的同步，它允许线程在某个条件满足时被唤醒。条件变量通常与互斥锁一起使用，一个线程在等待某个条件时，会先获取互斥锁，然后在条件变量上等待，此时线程会释放互斥锁并进入睡眠状态。当另一个线程改变了条件并通知条件变量时，等待的线程会被唤醒，重新获取互斥锁，然后检查条件是否满足。
- 相关函数：
pthread_cond_init函数：用于初始化一个条件变量。其函数原型为：
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
cond参数是指向要初始化的条件变量的指针，attr参数用于指定条件变量的属性，如果为NULL，则使用默认属性。
- pthread_cond_wait函数：用于在条件变量上等待。其函数原型为：
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
cond参数是要等待的条件变量，mutex参数是与条件变量关联的互斥锁。在调用该函数时，线程会先释放mutex，然后进入睡眠状态，当被唤醒时，线程会重新获取mutex。
- pthread_cond_signal函数：用于唤醒一个等待在条件变量上的线程。其函数原型为：
int pthread_cond_signal(pthread_cond_t *cond);
- **`pthread_cond_broadcast`函数**：用于唤醒所有等待在条件变量上的线程。其函数原型为：
int pthread_cond_broadcast(pthread_cond_t *cond);
- **`pthread_cond_destroy`函数**：用于销毁一个条件变量，释放相关资源。其函数原型为：
int pthread_cond_destroy(pthread_cond_t *cond);
- **示例代码**：下面是一个使用条件变量实现生产者 - 消费者模型的示例：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#define BUFFER_SIZE 5
// 共享缓冲区
int buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
// 互斥锁
pthread_mutex_t mutex;
// 条件变量
pthread_cond_t empty, full;
// 生产者线程函数
void* producer(void* arg) {
for (int i = 0; i < 10; i++) {
// 生成数据
int item = rand() % 100;
// 锁定互斥锁
pthread_mutex_lock(&mutex);
// 等待缓冲区有空间
while ((in + 1) % BUFFER_SIZE == out) {
pthread_cond_wait(&empty, &mutex);
}
// 将数据放入缓冲区
buffer[in] = item;
printf("Produced: %d\n", item);
in = (in + 1) % BUFFER_SIZE;
// 通知缓冲区有数据
pthread_cond_signal(&full);
// 解锁互斥锁
pthread_mutex_unlock(&mutex);
}
return NULL;
}
// 消费者线程函数
void* consumer(void* arg) {
for (int i = 0; i < 10; i++) {
// 锁定互斥锁
pthread_mutex_lock(&mutex);
// 等待缓冲区有数据
while (in == out) {
pthread_cond_wait(&full, &mutex);
}
// 从缓冲区取出数据
int item = buffer[out];
printf("Consumed: %d\n", item);
out = (out + 1) % BUFFER_SIZE;
// 通知缓冲区有空间
pthread_cond_signal(&empty);
// 解锁互斥锁
pthread_mutex_unlock(&mutex);
}
return NULL;
}
int main() {
pthread_t producer_thread, consumer_thread;
// 初始化互斥锁
if (pthread_mutex_init(&mutex, NULL) != 0) {
printf("\n ERROR initializing mutex");
return 1;
}
// 初始化条件变量
if (pthread_cond_init(&empty, NULL) != 0) {
printf("\n ERROR initializing empty condition variable");
return 2;
}
if (pthread_cond_init(&full, NULL) != 0) {
printf("\n ERROR initializing full condition variable");
return 3;
}
// 创建生产者线程
if (pthread_create(&producer_thread, NULL, producer, NULL) != 0) {
printf("\n ERROR creating producer thread");
return 4;
}
// 创建消费者线程
if (pthread_create(&consumer_thread, NULL, consumer, NULL) != 0) {
printf("\n ERROR creating consumer thread");
return 5;
}
// 等待生产者线程结束
if (pthread_join(producer_thread, NULL) != 0) {
printf("\n ERROR joining producer thread");
return 6;
}
// 等待消费者线程结束
if (pthread_join(consumer_thread, NULL) != 0) {
printf("\n ERROR joining consumer thread");
return 7;
}
// 销毁互斥锁
if (pthread_mutex_destroy(&mutex) != 0) {
printf("\n ERROR destroying mutex");
return 8;
}
// 销毁条件变量
if (pthread_cond_destroy(&empty) != 0) {
printf("\n ERROR destroying empty condition variable");
return 9;
}
if (pthread_cond_destroy(&full) != 0) {
printf("\n ERROR destroying full condition variable");
return 10;
}
return 0;
}
在上述代码中，生产者线程和消费者线程通过条件变量empty和full以及互斥锁mutex实现了同步，确保缓冲区的正确使用，避免了数据竞争和缓冲区溢出等问题。
- 信号量（Semaphore）
- 原理：信号量是一个整型变量，它可以用来控制对共享资源的访问数量。信号量的值表示当前可用的资源数量，当一个线程获取信号量（即信号量的值减1）时，如果信号量的值大于0，则获取成功，线程可以继续执行；如果信号量的值为0，则线程会被阻塞，直到有其他线程释放信号量（即信号量的值加1）。
- 相关函数：在POSIX线程模型中，虽然没有直接提供信号量类型，但可以通过
semaphore库来实现信号量的功能。相关函数有：sem_init函数：用于初始化一个信号量。其函数原型为：
int sem_init(sem_t *sem, int pshared, unsigned int value);
sem参数是指向要初始化的信号量变量的指针，pshared参数用于指定信号量是否在进程间共享（0表示线程间共享），value参数是信号量的初始值。
- sem_wait函数：用于获取信号量，即信号量的值减1。如果信号量的值为0，则线程会被阻塞。其函数原型为：
int sem_wait(sem_t *sem);
- **`sem_post`函数**：用于释放信号量，即信号量的值加1。其函数原型为：
int sem_post(sem_t *sem);
- **`sem_destroy`函数**：用于销毁一个信号量，释放相关资源。其函数原型为：
int sem_destroy(sem_t *sem);
- **示例代码**：下面是一个使用信号量来控制对共享资源访问数量的示例，假设有多个线程要访问一个共享文件，同时只允许3个线程访问：
#include <pthread.h>
#include <stdio.h>
#include <semaphore.h>
// 信号量
sem_t semaphore;
// 线程执行函数
void* access_file(void* arg) {
// 获取信号量
sem_wait(&semaphore);
printf("Thread %ld is accessing the file.\n", (long)pthread_self());
// 模拟文件访问操作
sleep(1);
printf("Thread %ld finished accessing the file.\n", (long)pthread_self());
// 释放信号量
sem_post(&semaphore);
return NULL;
}
int main() {
pthread_t threads[5];
// 初始化信号量，允许3个线程同时访问
if (sem_init(&semaphore, 0, 3) != 0) {
printf("\n ERROR initializing semaphore");
return 1;
}
// 创建5个线程
for (int i = 0; i < 5; i++) {
if (pthread_create(&threads[i], NULL, access_file, NULL) != 0) {
printf("\n ERROR creating thread %d", i);
return 2;
}
}
// 等待所有线程结束
for (int i = 0; i < 5; i++) {
if (pthread_join(threads[i], NULL) != 0) {
printf("\n ERROR joining thread %d", i);
return 3;
}
}
// 销毁信号量
if (sem_destroy(&semaphore) != 0) {
printf("\n ERROR destroying semaphore");
return 4;
}
return 0;
}
在上述代码中，通过信号量semaphore控制了同时访问共享文件的线程数量，确保不会有过多线程同时访问导致资源竞争问题。
多线程编程中的常见问题与解决方法
死锁问题
-
死锁的产生原因 死锁通常是由于多个线程相互等待对方释放资源而导致的。例如，线程A持有资源1并等待资源2，而线程B持有资源2并等待资源1，这样两个线程就会永远等待下去，形成死锁。死锁产生的四个必要条件是：
- 互斥条件：资源不能被共享，只能被一个线程占用。
- 占有并等待条件：线程已经占有了一些资源，并在等待其他资源时不释放已占有的资源。
- 不可剥夺条件：资源只能由占有它的线程主动释放，其他线程不能强行剥夺。
- 循环等待条件：存在一个线程的循环链，链中的每个线程都在等待下一个线程占有的资源。
-
死锁的检测与预防
- 死锁检测：在程序运行过程中，可以通过定期检查线程的资源占有和等待情况来检测死锁。一种简单的方法是使用资源分配图算法，如死锁检测算法（如银行家算法的变体），通过分析线程和资源之间的关系来判断是否存在死锁。但是，这种方法在实际应用中可能比较复杂，并且会带来一定的性能开销。
- 死锁预防：
- 破坏互斥条件：在某些情况下，可以通过改变资源的访问方式，使得资源可以被共享，从而避免互斥访问。例如，将一些只读资源设置为共享访问，不需要加锁。但这种方法并不适用于所有情况，因为很多资源需要保证数据的一致性，必须进行互斥访问。
- 破坏占有并等待条件：可以要求线程在开始运行前一次性获取所有需要的资源，而不是在运行过程中逐步获取。这样可以避免线程在占有部分资源的情况下等待其他资源。例如，在一个需要同时访问数据库和文件系统的程序中，线程在启动时就获取数据库连接和文件描述符，而不是先获取数据库连接，再等待文件描述符。
- 破坏不可剥夺条件：允许操作系统或其他机制在必要时剥夺线程占有的资源。例如，当一个线程等待资源的时间过长时，可以强制剥夺它占有的资源，分配给其他线程。但这种方法在实际应用中可能会导致数据不一致等问题，需要谨慎使用。
- 破坏循环等待条件：可以通过对资源进行排序，要求线程按照一定的顺序获取资源。例如，将所有资源编号，线程只能按照从小到大的顺序获取资源，这样就可以避免循环等待的情况。
数据竞争问题
-
数据竞争的产生原因 数据竞争是指多个线程同时访问和修改共享数据，而没有进行适当的同步，导致数据的不一致性。例如，两个线程同时对一个全局变量进行自增操作，如果没有加锁保护，可能会出现一个线程读取到的值还没有被另一个线程更新，从而导致最终结果错误。
-
数据竞争的解决方法
- 使用同步机制：如前文所述，通过使用互斥锁、条件变量、信号量等同步机制，可以保证在同一时间只有一个线程能够访问共享数据，从而避免数据竞争。在访问共享数据前，线程需要获取相应的锁，访问结束后释放锁。
- 使用线程局部存储（Thread - Local Storage，TLS）：线程局部存储是一种让每个线程拥有自己独立的数据副本的机制。通过将共享数据改为线程局部变量，每个线程操作自己的数据副本，不会相互干扰，从而避免数据竞争。在POSIX线程模型中，可以使用
pthread_key_create和pthread_getspecific等函数来实现线程局部存储。例如：
#include <pthread.h>
#include <stdio.h>
// 线程局部存储键
pthread_key_t key;
// 线程执行函数
void* thread_function(void* arg) {
// 获取线程局部存储的值
int* value = (int*)pthread_getspecific(key);
if (value == NULL) {
// 如果是第一次访问，初始化线程局部存储
value = (int*)malloc(sizeof(int));
*value = 0;
pthread_setspecific(key, value);
}
// 对线程局部存储的值进行操作
(*value)++;
printf("Thread %ld: value = %d\n", (long)pthread_self(), *value);
return NULL;
}
int main() {
pthread_t threads[3];
// 创建线程局部存储键
if (pthread_key_create(&key, NULL) != 0) {
printf("\n ERROR creating thread - local storage key");
return 1;
}
// 创建3个线程
for (int i = 0; i < 3; i++) {
if (pthread_create(&threads[i], NULL, thread_function, NULL) != 0) {
printf("\n ERROR creating thread %d", i);
return 2;
}
}
// 等待所有线程结束
for (int i = 0; i < 3; i++) {
if (pthread_join(threads[i], NULL) != 0) {
printf("\n ERROR joining thread %d", i);
return 3;
}
}
// 销毁线程局部存储键
if (pthread_key_delete(key) != 0) {
printf("\n ERROR deleting thread - local storage key");
return 4;
}
return 0;
}
在上述代码中，每个线程通过pthread_getspecific和pthread_setspecific函数操作自己的线程局部变量，避免了数据竞争。
性能问题
-
性能问题的产生原因 多线程编程虽然可以提高程序的并发性能，但如果使用不当，也可能会导致性能下降。常见的性能问题产生原因包括：
- 线程创建和销毁开销：创建和销毁线程需要一定的时间和资源，如果在程序中频繁地创建和销毁线程，会增加系统的开销，降低性能。
- 线程同步开销：使用同步机制（如互斥锁、条件变量等）会带来一定的开销，包括加锁、解锁、等待等操作。如果同步机制使用过于频繁，会导致线程之间的竞争加剧，降低程序的执行效率。
- CPU缓存一致性问题：多个线程同时访问共享数据时，可能会导致CPU缓存一致性问题。由于不同CPU核心的缓存可能不一致，当一个线程修改了共享数据后，其他线程需要从主内存中重新读取数据，这会增加数据访问的延迟。
-
性能优化方法
- 线程池：使用线程池可以避免频繁地创建和销毁线程。线程池是一组预先创建好的线程，任务可以提交到线程池中，由线程池中的线程来执行。这样可以减少线程创建和销毁的开销，提高程序的性能。在POSIX线程模型中，可以通过自己实现线程池数据结构和管理逻辑来实现线程池。例如，可以使用链表来管理线程池中的线程，使用队列来存储任务。
- 减少同步开销：尽量减少不必要的同步操作，只在真正需要保护共享资源的地方使用同步机制。同时，可以优化同步机制的使用方式，例如使用读写锁（
pthread_rwlock）来区分读操作和写操作，允许多个线程同时进行读操作，提高并发性能。 - 优化数据访问模式：尽量减少线程之间对共享数据的访问，将数据进行合理的划分，让每个线程尽量操作自己独立的数据。如果无法避免共享数据，可以通过调整数据结构和访问方式，减少CPU缓存一致性问题的影响。例如，将频繁访问的共享数据放在连续的内存空间中，利用CPU缓存的空间局部性原理，提高数据访问效率。
实际应用案例
- 网络服务器 在网络服务器开发中，多线程编程可以显著提高服务器的并发处理能力。例如，一个简单的TCP服务器可以为每个客户端连接分配一个线程来处理。以下是一个简单的示例代码：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define PORT 8080
#define MAX_CLIENTS 10
// 线程执行函数，处理客户端连接
void* handle_client(void* arg) {
int client_socket = *((int*)arg);
char buffer[1024] = {0};
int valread = read(client_socket, buffer, 1024);
if (valread < 0) {
perror("Read error");
} else if (valread > 0) {
buffer[valread] = '\0';
printf("Received: %s\n", buffer);
char response[] = "Hello from server!";
send(client_socket, response, strlen(response), 0);
}
close(client_socket);
return NULL;
}
int main(int argc, char const *argv[]) {
int server_fd, new_socket;
struct sockaddr_in address;
int opt = 1;
int addrlen = sizeof(address);
pthread_t threads[MAX_CLIENTS];
// 创建套接字
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror("Socket creation failed");
exit(EXIT_FAILURE);
}
// 设置套接字选项
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
perror("Setsockopt failed");
close(server_fd);
exit(EXIT_FAILURE);
}
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);
// 绑定套接字到地址和端口
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
perror("Bind failed");
close(server_fd);
exit(EXIT_FAILURE);
}
// 监听连接
if (listen(server_fd, MAX_CLIENTS) < 0) {
perror("Listen failed");
close(server_fd);
exit(EXIT_FAILURE);
}
printf("Server is listening on port %d...\n", PORT);
int client_count = 0;
while (1) {
if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
perror("Accept failed");
continue;
}
if (client_count < MAX_CLIENTS) {
int* client_socket_ptr = (int*)malloc(sizeof(int));
*client_socket_ptr = new_socket;
if (pthread_create(&threads[client_count], NULL, handle_client, client_socket_ptr) != 0) {
perror("Thread creation failed");
free(client_socket_ptr);
close(new_socket);
} else {
client_count++;
}
} else {
char response[] = "Server is busy, try again later.";
send(new_socket, response, strlen(response), 0);
close(new_socket);
}
}
// 等待所有线程结束
for (int i = 0; i < client_count; i++) {
pthread_join(threads[i], NULL);
}
close(server_fd);
return 0;
}
在上述代码中，主线程负责监听客户端连接，每当有新的客户端连接时，创建一个新的线程来处理该客户端的请求。这样服务器可以同时处理多个客户端的请求，提高了并发性能。
- 并行计算 在一些需要进行大量计算的应用中，多线程编程可以利用多核CPU的性能，实现并行计算。例如，计算一个数组中所有元素的和，可以将数组分成多个部分，每个线程计算一部分，最后将结果汇总。以下是一个示例代码：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#define ARRAY_SIZE 1000000
#define THREADS 4
// 线程参数结构体
typedef struct {
int* array;
int start;
int end;
int* result;
} ThreadArgs;
// 线程执行函数
void* sum_part(void* arg) {
ThreadArgs* args = (ThreadArgs*)arg;
int sum = 0;
for (int i = args->start; i < args->end; i++) {
sum += args->array[i];
}
*(args->result) = sum;
return NULL;
}
int main() {
int array[ARRAY_SIZE];
for (int i = 0; i < ARRAY_SIZE; i++) {
array[i] = i + 1;
}
pthread_t threads[THREADS];
ThreadArgs args[THREADS];
int results[THREADS];
int part_size = ARRAY_SIZE / THREADS;
for (int i = 0; i < THREADS; i++) {
args[i].array = array;
args[i].start = i * part_size;
args[i].end = (i == THREADS - 1)? ARRAY_SIZE : (i + 1) * part_size;
args[i].result = &results[i];
if (pthread_create(&threads[i], NULL, sum_part, &args[i]) != 0) {
printf("\n ERROR creating thread %d", i);
return 1;
}
}
for (int i = 0; i < THREADS; i++) {
if (pthread_join(threads[i], NULL) != 0) {
printf("\n ERROR joining thread %d", i);
return 2;
}
}
int total_sum = 0;
for (int i = 0; i < THREADS; i++) {
total_sum += results[i];
}
printf("Total sum: %d\n", total_sum);
return 0;
}
在上述代码中，将数组array分成THREADS个部分，每个线程负责计算一部分的和，最后将各个部分的和累加起来得到数组所有元素的总和。通过这种方式，充分利用了多核CPU的性能，加快了计算速度。
总结
C语言的多线程编程结合POSIX线程模型为开发人员提供了强大的工具来实现高效的并发程序。通过深入理解线程的创建、终止、同步等机制，以及解决多线程编程中常见的问题，开发人员可以编写出健壮、高效的多线程应用程序。无论是网络服务器、并行计算还是其他需要并发处理的场景，多线程编程都能发挥重要作用。在实际应用中，需要根据具体的需求和场景，合理地设计线程模型，选择合适的同步机制，以达到最佳的性能和稳定性。同时，不断地实践和优化代码，积累多线程编程的经验，对于提升开发技能和解决复杂问题的能力具有重要意义。