1. PingCode智库首页
  2. 百科

c语言如何做多线程

Edit2 • • 百科

c语言如何做多线程

C语言如何做多线程：使用POSIX线程库、创建线程、同步线程、管理线程

在C语言中实现多线程编程，通常使用POSIX线程库（pthread库）。首先，通过pthread_create函数创建新线程；其次，通过pthread_join函数同步线程；最后，通过pthread_mutex等机制管理线程资源。具体来说，使用POSIX线程库是最常见的方法。它提供了一整套用于线程创建、管理和同步的API，能够满足大多数多线程编程需求。

使用POSIX线程库（pthread库）时，首先需要包含库文件pthread.h，然后在编译时链接-lpthread库。创建线程的基本步骤包括定义线程函数、初始化线程属性、创建线程、同步线程以及销毁线程。以下是一个简单的线程创建示例：

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


void* myThreadFun(void* vargp) {


    printf("Printing from threadn");


    return NULL;


}


int main() {


    pthread_t thread_id;


    printf("Before Threadn");


    pthread_create(&thread_id, NULL, myThreadFun, NULL);


    pthread_join(thread_id, NULL);


    printf("After Threadn");


    exit(0);


}

一、使用POSIX线程库

1、线程的创建

在C语言中，创建线程的最基本方法是使用pthread_create函数。这个函数需要传递线程ID、线程属性、线程函数和传递给线程函数的参数。下面是一个详细的示例：

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


void* printMessage(void* msg) {


    char* message = (char*)msg;


    printf("%sn", message);


    return NULL;


}


int main() {


    pthread_t thread1, thread2;


    char* message1 = "Thread 1";


    char* message2 = "Thread 2";


    pthread_create(&thread1, NULL, printMessage, (void*)message1);


    pthread_create(&thread2, NULL, printMessage, (void*)message2);


    pthread_join(thread1, NULL);


    pthread_join(thread2, NULL);


    return 0;


}

这个示例中，两个线程分别打印不同的信息。使用pthread_create函数创建线程，并使用pthread_join函数等待线程结束。

2、线程的同步

线程同步是多线程编程中的关键问题。常见的同步机制包括互斥锁（Mutex）、条件变量（Condition Variable）和读写锁（Read-Write Lock）。下面介绍使用互斥锁进行线程同步的示例：

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


pthread_mutex_t lock;


int counter = 0;


void* incrementCounter(void* arg) {


    pthread_mutex_lock(&lock);


    counter++;


    printf("Counter: %dn", counter);


    pthread_mutex_unlock(&lock);


    return NULL;


}


int main() {


    pthread_t thread1, thread2;


    pthread_mutex_init(&lock, NULL);


    pthread_create(&thread1, NULL, incrementCounter, NULL);


    pthread_create(&thread2, NULL, incrementCounter, NULL);


    pthread_join(thread1, NULL);


    pthread_join(thread2, NULL);


    pthread_mutex_destroy(&lock);


    return 0;


}

在这个示例中，使用互斥锁保护共享资源counter，确保多个线程对其进行操作时不会发生冲突。

二、线程管理

1、线程属性的设置

在创建线程时，可以通过pthread_attr_t结构体设置线程属性，如分离状态、堆栈大小等。下面是设置线程为分离状态的示例：

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


void* printMessage(void* msg) {


    char* message = (char*)msg;


    printf("%sn", message);


    return NULL;


}


int main() {


    pthread_t thread;


    pthread_attr_t attr;


    pthread_attr_init(&attr);


    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);


    pthread_create(&thread, &attr, printMessage, "Detached Thread");


    pthread_attr_destroy(&attr);


    pthread_exit(NULL);


}

分离状态的线程在结束时会自动释放资源，而不需要调用pthread_join。

2、线程的取消

在某些情况下，需要取消正在运行的线程。可以使用pthread_cancel函数实现这一功能。下面是一个取消线程的示例：

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


void* printMessage(void* arg) {


    while (1) {


        printf("Running...n");


        sleep(1);


    }


    return NULL;


}


int main() {


    pthread_t thread;


    pthread_create(&thread, NULL, printMessage, NULL);


    sleep(3);


    pthread_cancel(thread);


    pthread_join(thread, NULL);


    printf("Thread cancelledn");


    return 0;


}

在这个示例中，主线程在睡眠3秒后取消子线程的执行。

三、线程间通信

1、使用全局变量

最简单的线程间通信方法是使用全局变量。然而，这种方法需要配合同步机制（如互斥锁）以避免数据竞争。以下是一个使用全局变量进行线程通信的示例：

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


pthread_mutex_t lock;


int sharedVar = 0;


void* incrementSharedVar(void* arg) {


    pthread_mutex_lock(&lock);


    sharedVar++;


    printf("Shared Variable: %dn", sharedVar);


    pthread_mutex_unlock(&lock);


    return NULL;


}


int main() {


    pthread_t thread1, thread2;


    pthread_mutex_init(&lock, NULL);


    pthread_create(&thread1, NULL, incrementSharedVar, NULL);


    pthread_create(&thread2, NULL, incrementSharedVar, NULL);


    pthread_join(thread1, NULL);


    pthread_join(thread2, NULL);


    pthread_mutex_destroy(&lock);


    return 0;


}

在这个示例中，两个线程通过全局变量sharedVar进行通信，并使用互斥锁保护共享资源。

2、使用条件变量

条件变量允许线程在某些条件满足时进行通信。以下是一个使用条件变量进行线程通信的示例：

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


pthread_mutex_t lock;


pthread_cond_t cond;


int ready = 0;


void* waitForSignal(void* arg) {


    pthread_mutex_lock(&lock);


    while (!ready) {


        pthread_cond_wait(&cond, &lock);


    }


    printf("Signal receivedn");


    pthread_mutex_unlock(&lock);


    return NULL;


}


void* sendSignal(void* arg) {


    pthread_mutex_lock(&lock);


    ready = 1;


    pthread_cond_signal(&cond);


    printf("Signal sentn");


    pthread_mutex_unlock(&lock);


    return NULL;


}


int main() {


    pthread_t thread1, thread2;


    pthread_mutex_init(&lock, NULL);


    pthread_cond_init(&cond, NULL);


    pthread_create(&thread1, NULL, waitForSignal, NULL);


    pthread_create(&thread2, NULL, sendSignal, NULL);


    pthread_join(thread1, NULL);


    pthread_join(thread2, NULL);


    pthread_mutex_destroy(&lock);


    pthread_cond_destroy(&cond);


    return 0;


}

在这个示例中，waitForSignal线程等待条件变量的信号，而sendSignal线程发送信号。

四、多线程编程的最佳实践

1、避免死锁

在多线程编程中，死锁是一个常见问题。死锁发生时，两个或多个线程相互等待对方释放资源，导致程序无法继续执行。为了避免死锁，应遵循以下原则：

  • 尽量减少锁的使用：仅在必要时使用锁。
  • 按顺序加锁：确保所有线程以相同的顺序获取多个锁。
  • 使用定时锁：在尝试获取锁时设置超时时间，避免无限等待。

2、合理划分任务

在多线程编程中，合理划分任务可以提高程序的性能和效率。应尽量将任务划分为独立的、可以并行执行的部分，避免线程间的频繁通信和同步。

3、调试和测试

多线程编程的调试和测试相对复杂。在开发过程中，应使用适当的调试工具和技术，如：

  • 日志记录：在关键位置添加日志记录，方便追踪线程的执行过程。
  • 断点调试：使用断点调试工具，逐步检查线程的执行情况。
  • 单元测试：编写单元测试，验证各个线程的功能和性能。

五、C语言多线程编程的高级应用

1、线程池

线程池是一种常用的多线程编程技术，用于管理和复用多个线程。线程池可以减少线程创建和销毁的开销，提高程序的性能。以下是一个简单的线程池实现示例：

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


#define THREAD_POOL_SIZE 4


typedef struct {


    void (*function)(void*);


    void* arg;


} ThreadTask;


pthread_t threadPool[THREAD_POOL_SIZE];


pthread_mutex_t lock;


pthread_cond_t cond;


ThreadTask taskQueue[10];


int taskCount = 0;


void* threadWorker(void* arg) {


    while (1) {


        pthread_mutex_lock(&lock);


        while (taskCount == 0) {


            pthread_cond_wait(&cond, &lock);


        }


        ThreadTask task = taskQueue[--taskCount];


        pthread_mutex_unlock(&lock);


        task.function(task.arg);


    }


    return NULL;


}


void submitTask(void (*function)(void*), void* arg) {


    pthread_mutex_lock(&lock);


    taskQueue[taskCount++] = (ThreadTask){function, arg};


    pthread_cond_signal(&cond);


    pthread_mutex_unlock(&lock);


}


void printMessage(void* msg) {


    char* message = (char*)msg;


    printf("%sn", message);


}


int main() {


    pthread_mutex_init(&lock, NULL);


    pthread_cond_init(&cond, NULL);


    for (int i = 0; i < THREAD_POOL_SIZE; i++) {


        pthread_create(&threadPool[i], NULL, threadWorker, NULL);


    }


    submitTask(printMessage, "Task 1");


    submitTask(printMessage, "Task 2");


    submitTask(printMessage, "Task 3");


    for (int i = 0; i < THREAD_POOL_SIZE; i++) {


        pthread_join(threadPool[i], NULL);


    }


    pthread_mutex_destroy(&lock);


    pthread_cond_destroy(&cond);


    return 0;


}

在这个示例中，创建了一个包含4个线程的线程池，并通过任务队列管理任务的提交和执行。

2、并行计算

并行计算是多线程编程的一大应用领域。通过将计算任务划分为多个线程并行执行，可以显著提高计算效率。以下是一个使用多线程进行矩阵乘法的示例：

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


#define MATRIX_SIZE 4


int matrixA[MATRIX_SIZE][MATRIX_SIZE];


int matrixB[MATRIX_SIZE][MATRIX_SIZE];


int result[MATRIX_SIZE][MATRIX_SIZE];


typedef struct {


    int row;


    int col;


} ThreadData;


void* multiplyMatrix(void* arg) {


    ThreadData* data = (ThreadData*)arg;


    int row = data->row;


    int col = data->col;


    result[row][col] = 0;


    for (int i = 0; i < MATRIX_SIZE; i++) {


        result[row][col] += matrixA[row][i] * matrixB[i][col];


    }


    free(data);


    return NULL;


}


int main() {


    pthread_t threads[MATRIX_SIZE][MATRIX_SIZE];


    // Initialize matrices


    for (int i = 0; i < MATRIX_SIZE; i++) {


        for (int j = 0; j < MATRIX_SIZE; j++) {


            matrixA[i][j] = rand() % 10;


            matrixB[i][j] = rand() % 10;


        }


    }


    // Create threads for matrix multiplication


    for (int i = 0; i < MATRIX_SIZE; i++) {


        for (int j = 0; j < MATRIX_SIZE; j++) {


            ThreadData* data = (ThreadData*)malloc(sizeof(ThreadData));


            data->row = i;


            data->col = j;


            pthread_create(&threads[i][j], NULL, multiplyMatrix, (void*)data);


        }


    }


    // Join threads


    for (int i = 0; i < MATRIX_SIZE; i++) {


        for (int j = 0; j < MATRIX_SIZE; j++) {


            pthread_join(threads[i][j], NULL);


        }


    }


    // Print result matrix


    for (int i = 0; i < MATRIX_SIZE; i++) {


        for (int j = 0; j < MATRIX_SIZE; j++) {


            printf("%d ", result[i][j]);


        }


        printf("n");


    }


    return 0;


}

在这个示例中，每个线程负责计算结果矩阵中的一个元素，从而实现矩阵乘法的并行计算。

六、总结

C语言多线程编程通过使用POSIX线程库（pthread库）实现，主要包括线程的创建、同步、管理和通信。在实际应用中，应合理划分任务、避免死锁，并遵循多线程编程的最佳实践。通过学习和掌握这些技术，开发者可以有效提升程序的性能和效率。

在项目管理方面，推荐使用研发项目管理系统PingCode，和通用项目管理软件Worktile，它们提供了强大的功能，能够帮助开发团队高效管理多线程编程项目。

相关问答FAQs：

1. 如何在C语言中实现多线程编程？
C语言中可以使用线程库来实现多线程编程，比如POSIX线程库(pthread)。通过使用pthread库中的相关函数，可以创建多个线程并让它们并发地执行。

2. 如何在C语言中实现线程间的通信？
在线程间进行通信可以使用共享内存、消息队列或者信号量等机制。可以使用C语言提供的相应库函数来实现这些机制，比如共享内存可以使用mmap()函数，消息队列可以使用msgget()和msgsnd()函数，信号量可以使用sem_init()和sem_post()函数。

3. C语言中如何处理多线程的竞争条件？
在多线程编程中，由于线程是并发执行的，可能会导致多个线程同时访问共享资源，从而造成竞争条件。为了解决这个问题，可以使用互斥锁(mutex)来保护共享资源的访问，确保同一时间只有一个线程可以访问。C语言提供了pthread_mutex_init()、pthread_mutex_lock()和pthread_mutex_unlock()等函数来实现互斥锁的使用。

原创文章，作者：Edit2，如若转载，请注明出处：https://docs.pingcode.com/baike/1011933

赞 (0)
Edit2Edit2
上一篇 2024年8月27日 上午10:59
下一篇 2024年8月27日 上午10:59
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部