1. PingCode智库首页
  2. 百科

linux c语言如何创建多线程

Edit2 • • 百科

linux c语言如何创建多线程

在Linux系统中，使用C语言创建多线程的方式主要有：使用POSIX线程（pthread）库、定义线程函数、创建线程、同步线程。本文将详细介绍如何在Linux系统中使用C语言创建多线程，并讨论一些与多线程编程相关的重要概念和最佳实践。

一、使用POSIX线程（pthread）库

1.1、简介

POSIX线程（pthread）库是一个跨平台的线程库，它提供了一组标准的API来创建和管理线程。pthread库在大多数Unix-like系统（包括Linux）中得到了广泛的支持。

1.2、安装和包含头文件

在Linux系统上，pthread库通常默认安装。要使用pthread库，需要包含pthread.h头文件，并在编译时链接pthread库。示例代码如下：

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


void *thread_function(void *arg) {


    printf("Hello from thread!n");


    return NULL;


}


int main() {


    pthread_t thread;


    int result;


    result = pthread_create(&thread, NULL, thread_function, NULL);


    if (result) {


        fprintf(stderr, "Error creating threadn");


        return 1;


    }


    pthread_join(thread, NULL);


    return 0;


}

在编译时，使用-pthread选项链接pthread库：

gcc -pthread -o myprogram myprogram.c

二、定义线程函数

2.1、基本定义

在线程创建过程中，需要定义一个线程函数，该函数将在线程中运行。线程函数必须符合以下签名：

void *thread_function(void *arg);

其中，arg是传递给线程函数的参数，可以是任何类型。线程函数的返回值类型是void *，返回值通常用于线程的退出状态。

2.2、示例代码

以下是一个简单的线程函数示例，它接受一个整数参数并打印：

void *print_numbers(void *arg) {


    int num = *((int *)arg);


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


        printf("Thread: %dn", i);


    }


    return NULL;


}

三、创建线程

3.1、pthread_create函数

要创建线程，使用pthread_create函数。其原型如下：

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

参数说明：

  • thread：指向线程标识符的指针。
  • attr：线程属性，通常使用NULL表示默认属性。
  • start_routine：指向线程函数的指针。
  • arg：传递给线程函数的参数。

3.2、示例代码

以下代码演示了如何创建一个线程，并将整数参数传递给线程函数：

int main() {


    pthread_t thread;


    int num = 10;


    int result = pthread_create(&thread, NULL, print_numbers, &num);


    if (result) {


        fprintf(stderr, "Error creating threadn");


        return 1;


    }


    pthread_join(thread, NULL);


    return 0;


}

四、同步线程

4.1、pthread_join函数

pthread_join函数用于等待指定的线程终止。其原型如下：

int pthread_join(pthread_t thread, void retval);

参数说明：

  • thread：要等待的线程的标识符。
  • retval：指向线程函数返回值的指针。

4.2、示例代码

以下代码演示了如何使用pthread_join等待线程结束：

int main() {


    pthread_t thread;


    int num = 10;


    int result = pthread_create(&thread, NULL, print_numbers, &num);


    if (result) {


        fprintf(stderr, "Error creating threadn");


        return 1;


    }


    result = pthread_join(thread, NULL);


    if (result) {


        fprintf(stderr, "Error joining threadn");


        return 1;


    }


    return 0;


}

五、线程同步机制

5.1、互斥锁（Mutex）

互斥锁（Mutex）用于防止多个线程同时访问共享资源。要使用互斥锁，需要定义一个pthread_mutex_t变量，并初始化、加锁和解锁。

示例代码：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;


void *thread_function(void *arg) {


    pthread_mutex_lock(&mutex);


    // 访问共享资源


    pthread_mutex_unlock(&mutex);


    return NULL;


}

5.2、条件变量（Condition Variable）

条件变量用于在线程之间同步某个条件的发生。要使用条件变量，需要定义一个pthread_cond_t变量，并初始化、等待和通知。

示例代码：

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;


pthread_mutex_t cond_mutex = PTHREAD_MUTEX_INITIALIZER;


void *wait_function(void *arg) {


    pthread_mutex_lock(&cond_mutex);


    pthread_cond_wait(&cond, &cond_mutex);


    // 条件满足，继续执行


    pthread_mutex_unlock(&cond_mutex);


    return NULL;


}


void *signal_function(void *arg) {


    pthread_mutex_lock(&cond_mutex);


    pthread_cond_signal(&cond);


    pthread_mutex_unlock(&cond_mutex);


    return NULL;


}

六、线程池

6.1、简介

线程池是一种管理线程的机制，可以减少创建和销毁线程的开销。线程池预先创建一定数量的线程，当有任务时，将任务分配给空闲线程执行。

6.2、实现线程池

实现线程池需要以下步骤：

  1. 创建固定数量的线程。
  2. 使用任务队列存储待执行的任务。
  3. 使用互斥锁和条件变量管理任务队列。

示例代码：

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


#include <unistd.h>


#define THREAD_POOL_SIZE 4


typedef struct {


    void (*function)(void *);


    void *arg;


} thread_task_t;


typedef struct {


    pthread_mutex_t mutex;


    pthread_cond_t cond;


    pthread_t threads[THREAD_POOL_SIZE];


    thread_task_t *task_queue;


    int queue_size;


    int queue_head;


    int queue_tail;


    int shutdown;


} thread_pool_t;


thread_pool_t pool;


void *thread_pool_worker(void *arg) {


    while (1) {


        pthread_mutex_lock(&pool.mutex);


        while (pool.queue_size == 0 && !pool.shutdown) {


            pthread_cond_wait(&pool.cond, &pool.mutex);


        }


        if (pool.shutdown) {


            pthread_mutex_unlock(&pool.mutex);


            break;


        }


        thread_task_t task = pool.task_queue[pool.queue_head];


        pool.queue_head = (pool.queue_head + 1) % THREAD_POOL_SIZE;


        pool.queue_size--;


        pthread_mutex_unlock(&pool.mutex);


        task.function(task.arg);


    }


    return NULL;


}


void thread_pool_init(int queue_size) {


    pthread_mutex_init(&pool.mutex, NULL);


    pthread_cond_init(&pool.cond, NULL);


    pool.task_queue = malloc(sizeof(thread_task_t) * queue_size);


    pool.queue_size = 0;


    pool.queue_head = 0;


    pool.queue_tail = 0;


    pool.shutdown = 0;


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


        pthread_create(&pool.threads[i], NULL, thread_pool_worker, NULL);


    }


}


void thread_pool_shutdown() {


    pthread_mutex_lock(&pool.mutex);


    pool.shutdown = 1;


    pthread_cond_broadcast(&pool.cond);


    pthread_mutex_unlock(&pool.mutex);


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


        pthread_join(pool.threads[i], NULL);


    }


    pthread_mutex_destroy(&pool.mutex);


    pthread_cond_destroy(&pool.cond);


    free(pool.task_queue);


}


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


    pthread_mutex_lock(&pool.mutex);


    pool.task_queue[pool.queue_tail].function = function;


    pool.task_queue[pool.queue_tail].arg = arg;


    pool.queue_tail = (pool.queue_tail + 1) % THREAD_POOL_SIZE;


    pool.queue_size++;


    pthread_cond_signal(&pool.cond);


    pthread_mutex_unlock(&pool.mutex);


}


void example_task(void *arg) {


    int num = *((int *)arg);


    printf("Task: %dn", num);


    sleep(1);


}


int main() {


    thread_pool_init(10);


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


        int *num = malloc(sizeof(int));


        *num = i;


        thread_pool_add_task(example_task, num);


    }


    sleep(10);


    thread_pool_shutdown();


    return 0;


}

七、最佳实践

7.1、避免竞争条件

竞争条件是指多个线程同时访问共享资源时，可能导致数据不一致的问题。使用互斥锁和条件变量可以避免竞争条件。

7.2、合理使用线程数量

创建过多线程可能导致系统开销增加，合理使用线程数量可以提高程序性能。使用线程池可以有效管理线程数量。

7.3、使用项目管理系统

在多线程开发过程中，使用项目管理系统可以提高开发效率和质量。推荐使用研发项目管理系统PingCode和通用项目管理软件Worktile。

7.4、调试和测试

多线程程序的调试和测试比较复杂，建议使用工具和方法如gdb、valgrind进行调试和内存泄漏检测。

通过以上内容的详细介绍，相信读者已经对Linux C语言创建多线程有了深入的了解和掌握。在实际开发中，合理使用多线程技术可以显著提高程序的效率和性能。

相关问答FAQs：

Q: 如何在Linux下使用C语言创建多线程？
A: 在Linux下，可以使用C语言的多线程库pthread来创建多线程。可以通过包含pthread.h头文件，并使用pthread_create函数来创建线程。

Q: 如何传递参数给Linux下的C语言多线程？
A: 在Linux下，可以通过将参数封装在结构体中，然后将结构体作为参数传递给pthread_create函数的最后一个参数来传递参数给C语言多线程。线程函数可以通过强制类型转换将参数解包。

Q: 如何等待Linux下的C语言多线程完成执行？
A: 在Linux下，可以使用pthread_join函数来等待C语言多线程的执行完成。可以在主线程中调用pthread_join函数，并将要等待的线程作为参数传递给该函数。这样主线程会一直等待，直到指定的线程执行完成。

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

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

4008001024

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