1. PingCode智库首页
  2. 百科

c语言如何同时执行两个函数

Edit2 • • 百科

c语言如何同时执行两个函数

在C语言中，同时执行两个函数的方法包括使用多线程、使用异步编程、利用信号处理等，最常用且有效的方法是多线程编程。多线程编程不仅可以提高程序的执行效率，还可以优化资源利用。在这里，我们详细讨论多线程编程的实现。

一、多线程编程概述

多线程编程是指在一个程序内同时执行多个线程，每个线程可以执行不同的函数。线程是轻量级进程，它们共享进程的资源，但有独立的执行路径。通过多线程编程，可以实现并发处理，从而提高程序的响应速度和效率。

1.1 多线程的优点

  1. 提高性能：通过并行执行任务，可以充分利用多核处理器的能力，提高程序的执行速度。
  2. 资源共享：线程共享进程的资源，如内存空间，因此可以更高效地进行资源管理。
  3. 响应性：在用户界面编程中，多线程可以提高程序的响应性，避免界面卡顿。

1.2 多线程的缺点

  1. 同步问题：由于多个线程共享资源，可能会出现竞争条件，需要使用同步机制（如互斥锁）来保护共享资源。
  2. 调试复杂：多线程程序的调试较为复杂，因为线程的执行顺序是不确定的，容易产生难以复现的错误。
  3. 开销：线程的创建和切换有一定的开销，过多的线程可能会导致系统性能下降。

二、使用POSIX线程库（Pthreads）

POSIX线程库（Pthreads）是C语言中实现多线程的标准库，适用于Unix及类似操作系统。通过Pthreads，可以方便地创建和管理线程。

2.1 创建线程

在Pthreads中，使用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：传递给线程函数的参数。

2.2 示例代码

下面是一个简单的示例，演示如何使用Pthreads创建两个线程，并让它们同时执行不同的函数：

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


// 线程函数1


void *function1(void *arg) {


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


        printf("Function 1: %dn", i);


        sleep(1);


    }


    return NULL;


}


// 线程函数2


void *function2(void *arg) {


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


        printf("Function 2: %dn", i);


        sleep(1);


    }


    return NULL;


}


int main() {


    pthread_t thread1, thread2;


    // 创建线程1


    if (pthread_create(&thread1, NULL, function1, NULL) != 0) {


        perror("Failed to create thread1");


        return 1;


    }


    // 创建线程2


    if (pthread_create(&thread2, NULL, function2, NULL) != 0) {


        perror("Failed to create thread2");


        return 1;


    }


    // 等待线程1结束


    pthread_join(thread1, NULL);


    // 等待线程2结束


    pthread_join(thread2, NULL);


    return 0;


}

2.3 线程同步

在多线程编程中，线程之间的同步是一个重要问题。常用的同步机制包括互斥锁（mutex）、读写锁（rwlock）和条件变量（condition variable）。

2.3.1 互斥锁（Mutex）

互斥锁用于保护共享资源，防止多个线程同时访问。使用pthread_mutex_t类型的变量来定义互斥锁，并使用pthread_mutex_init函数进行初始化。

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


pthread_mutex_t mutex;


void *function1(void *arg) {


    pthread_mutex_lock(&mutex);


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


        printf("Function 1: %dn", i);


        sleep(1);


    }


    pthread_mutex_unlock(&mutex);


    return NULL;


}


void *function2(void *arg) {


    pthread_mutex_lock(&mutex);


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


        printf("Function 2: %dn", i);


        sleep(1);


    }


    pthread_mutex_unlock(&mutex);


    return NULL;


}


int main() {


    pthread_t thread1, thread2;


    pthread_mutex_init(&mutex, NULL);


    if (pthread_create(&thread1, NULL, function1, NULL) != 0) {


        perror("Failed to create thread1");


        return 1;


    }


    if (pthread_create(&thread2, NULL, function2, NULL) != 0) {


        perror("Failed to create thread2");


        return 1;


    }


    pthread_join(thread1, NULL);


    pthread_join(thread2, NULL);


    pthread_mutex_destroy(&mutex);


    return 0;


}

在上述代码中，pthread_mutex_lock和pthread_mutex_unlock函数用于加锁和解锁共享资源。

2.3.2 读写锁（RWLock）

读写锁允许多个线程同时读共享资源，但在写操作时只允许一个线程进行。

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


pthread_rwlock_t rwlock;


void *reader(void *arg) {


    pthread_rwlock_rdlock(&rwlock);


    printf("Reader: Reading datan");


    sleep(1);


    pthread_rwlock_unlock(&rwlock);


    return NULL;


}


void *writer(void *arg) {


    pthread_rwlock_wrlock(&rwlock);


    printf("Writer: Writing datan");


    sleep(1);


    pthread_rwlock_unlock(&rwlock);


    return NULL;


}


int main() {


    pthread_t thread1, thread2;


    pthread_rwlock_init(&rwlock, NULL);


    if (pthread_create(&thread1, NULL, reader, NULL) != 0) {


        perror("Failed to create reader thread");


        return 1;


    }


    if (pthread_create(&thread2, NULL, writer, NULL) != 0) {


        perror("Failed to create writer thread");


        return 1;


    }


    pthread_join(thread1, NULL);


    pthread_join(thread2, NULL);


    pthread_rwlock_destroy(&rwlock);


    return 0;


}

2.4 条件变量（Condition Variable）

条件变量用于线程间的等待和通知机制。通常与互斥锁结合使用。

#include <pthread.h>


#include <stdio.h>


#include <stdlib.h>


pthread_mutex_t mutex;


pthread_cond_t cond;


void *waiter(void *arg) {


    pthread_mutex_lock(&mutex);


    printf("Waiter: Waiting for signaln");


    pthread_cond_wait(&cond, &mutex);


    printf("Waiter: Received signaln");


    pthread_mutex_unlock(&mutex);


    return NULL;


}


void *signaler(void *arg) {


    sleep(2); // 等待2秒，模拟信号发送前的操作


    pthread_mutex_lock(&mutex);


    printf("Signaler: Sending signaln");


    pthread_cond_signal(&cond);


    pthread_mutex_unlock(&mutex);


    return NULL;


}


int main() {


    pthread_t thread1, thread2;


    pthread_mutex_init(&mutex, NULL);


    pthread_cond_init(&cond, NULL);


    if (pthread_create(&thread1, NULL, waiter, NULL) != 0) {


        perror("Failed to create waiter thread");


        return 1;


    }


    if (pthread_create(&thread2, NULL, signaler, NULL) != 0) {


        perror("Failed to create signaler thread");


        return 1;


    }


    pthread_join(thread1, NULL);


    pthread_join(thread2, NULL);


    pthread_mutex_destroy(&mutex);


    pthread_cond_destroy(&cond);


    return 0;


}

三、使用标准库thread.h

在C11标准中，引入了标准库<threads.h>，提供了跨平台的多线程支持。相比于Pthreads，<threads.h>更容易使用且具有更好的可移植性。

3.1 创建线程

使用thrd_create函数来创建线程。其原型如下：

int thrd_create(thrd_t *thr, thrd_start_t func, void *arg);

  • thr：指向线程标识符的指针。
  • func：线程执行的函数。
  • arg：传递给线程函数的参数。

3.2 示例代码

下面是一个简单的示例，演示如何使用<threads.h>创建两个线程，并让它们同时执行不同的函数：

#include <threads.h>


#include <stdio.h>


#include <stdlib.h>


// 线程函数1


int function1(void *arg) {


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


        printf("Function 1: %dn", i);


        thrd_sleep(&(struct timespec){.tv_sec = 1}, NULL);


    }


    return 0;


}


// 线程函数2


int function2(void *arg) {


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


        printf("Function 2: %dn", i);


        thrd_sleep(&(struct timespec){.tv_sec = 1}, NULL);


    }


    return 0;


}


int main() {


    thrd_t thread1, thread2;


    // 创建线程1


    if (thrd_create(&thread1, function1, NULL) != thrd_success) {


        perror("Failed to create thread1");


        return 1;


    }


    // 创建线程2


    if (thrd_create(&thread2, function2, NULL) != thrd_success) {


        perror("Failed to create thread2");


        return 1;


    }


    // 等待线程1结束


    thrd_join(thread1, NULL);


    // 等待线程2结束


    thrd_join(thread2, NULL);


    return 0;


}

3.3 线程同步

在<threads.h>中，同样提供了互斥锁和条件变量等同步机制。

3.3.1 互斥锁（Mutex）

使用mtx_t类型的变量来定义互斥锁，并使用mtx_init函数进行初始化。

#include <threads.h>


#include <stdio.h>


#include <stdlib.h>


mtx_t mutex;


int function1(void *arg) {


    mtx_lock(&mutex);


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


        printf("Function 1: %dn", i);


        thrd_sleep(&(struct timespec){.tv_sec = 1}, NULL);


    }


    mtx_unlock(&mutex);


    return 0;


}


int function2(void *arg) {


    mtx_lock(&mutex);


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


        printf("Function 2: %dn", i);


        thrd_sleep(&(struct timespec){.tv_sec = 1}, NULL);


    }


    mtx_unlock(&mutex);


    return 0;


}


int main() {


    thrd_t thread1, thread2;


    mtx_init(&mutex, mtx_plain);


    if (thrd_create(&thread1, function1, NULL) != thrd_success) {


        perror("Failed to create thread1");


        return 1;


    }


    if (thrd_create(&thread2, function2, NULL) != thrd_success) {


        perror("Failed to create thread2");


        return 1;


    }


    thrd_join(thread1, NULL);


    thrd_join(thread2, NULL);


    mtx_destroy(&mutex);


    return 0;


}

3.3.2 条件变量（Condition Variable）

条件变量用于线程间的等待和通知机制。通常与互斥锁结合使用。

#include <threads.h>


#include <stdio.h>


#include <stdlib.h>


mtx_t mutex;


cnd_t cond;


int waiter(void *arg) {


    mtx_lock(&mutex);


    printf("Waiter: Waiting for signaln");


    cnd_wait(&cond, &mutex);


    printf("Waiter: Received signaln");


    mtx_unlock(&mutex);


    return 0;


}


int signaler(void *arg) {


    thrd_sleep(&(struct timespec){.tv_sec = 2}, NULL); // 等待2秒，模拟信号发送前的操作


    mtx_lock(&mutex);


    printf("Signaler: Sending signaln");


    cnd_signal(&cond);


    mtx_unlock(&mutex);


    return 0;


}


int main() {


    thrd_t thread1, thread2;


    mtx_init(&mutex, mtx_plain);


    cnd_init(&cond);


    if (thrd_create(&thread1, waiter, NULL) != thrd_success) {


        perror("Failed to create waiter thread");


        return 1;


    }


    if (thrd_create(&thread2, signaler, NULL) != thrd_success) {


        perror("Failed to create signaler thread");


        return 1;


    }


    thrd_join(thread1, NULL);


    thrd_join(thread2, NULL);


    mtx_destroy(&mutex);


    cnd_destroy(&cond);


    return 0;


}

四、异步编程

异步编程是一种不依赖线程的并发编程方式，通过事件驱动机制来实现任务的并行执行。常用的异步编程库有libuv等。

4.1 libuv库

libuv是一个多平台的异步I/O库，广泛应用于Node.js等项目。通过libuv，可以实现异步I/O操作、定时器、线程池等功能。

4.2 示例代码

下面是一个简单的示例，演示如何使用libuv实现两个函数的同时执行：

#include <uv.h>


#include <stdio.h>


// 回调函数1


void function1(uv_timer_t* handle) {


    static int count = 0;


    printf("Function 1: %dn", count++);


    if (count >= 5) {


        uv_timer_stop(handle);


    }


}


// 回调函数2


void function2(uv_timer_t* handle) {


    static int count = 0;


    printf("Function 2: %dn", count++);


    if (count >= 5) {


        uv_timer_stop(handle);


    }


}


int main() {


    uv_loop_t* loop = uv_default_loop();


    uv_timer_t timer1, timer2;


    uv_timer_init(loop, &timer1);


    uv_timer_start(&timer1, function1, 0, 1000);


    uv_timer_init(loop, &timer2);


    uv_timer_start(&timer2, function2, 0, 1000);


    uv_run(loop, UV_RUN_DEFAULT);


    uv_loop_close(loop);


    return 0;


}

在上述代码中，使用libuv的定时器功能，每隔1秒执行一次回调函数function1和function2。

五、信号处理

信号处理是一种基于信号的并发编程方式，通过捕捉和处理信号，可以在信号处理函数中执行任务。

5.1 示例代码

下面是一个简单的示例，演示如何使用信号处理实现两个函数的同时执行：

#include <signal.h>


#include <stdio.h>


#include <unistd.h>


// 信号处理函数1


void handler1(int signum) {


    static int count = 0;


    printf("Handler 1: %dn", count++);


    if (count >= 5) {


        signal(SIGALRM, SIG_DFL);


    }


}


// 信号处理函数2


void handler2(int signum) {


    static int count = 0;


    printf("Handler 2: %dn", count++);


    if (count >= 5) {


        signal(SIGUSR1, SIG_DFL);


    }


}


int main() {


    signal(SIGALRM, handler1);


    signal(SIGUSR1, handler2);


    // 发送信号


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


        raise(SIGALRM);


        raise(SIGUSR1);


        sleep(1);


    }


    return 0;


}

在上述代码中，使用signal函数注册信号处理函数，每次发送信号时，分别执行handler1和handler2。

六、总结

在C语言中，同时执行两个函数的方法主要包括多线程编程、异步编程、信号处理等。其中，多线程编程是最常用且有效的方法。通过使用POSIX线程库（Pthreads）或标准库<threads.h>，可以方便地创建和管理线程，实现并发处理。此外，异步编程和信号处理也是实现并发执行的方法，但它们的应用场景和复杂度有所不同。在实际开发中，可以根据具体需求选择合适的并发编程方式。对于项目管理，可以使用研发项目管理系统PingCode和通用项目管理软件Worktile来提高开发效率和管理水平。

相关问答FAQs：

1. 如何在C语言中同时执行两个函数？
在C语言中，要同时执行两个函数，可以使用多线程的方式。使用多线程可以让程序同时运行多个函数，提高程序的并发性和效率。可以使用C语言提供的线程库，如pthread库，在程序中创建两个线程分别执行两个函数。

2. 如何在C语言中实现函数的并发执行？
要实现函数的并发执行，可以使用线程库来创建多个线程，每个线程负责执行一个函数。在C语言中，可以使用pthread_create函数来创建线程，并使用pthread_join函数等待线程的结束。通过这种方式，可以让多个函数同时执行，提高程序的并发性。

3. 如何在C语言中实现函数的异步执行？
要实现函数的异步执行，可以使用线程库中提供的异步函数调用方式。在C语言中，可以使用pthread库中的pthread_create函数创建一个新线程，并在该线程中调用需要异步执行的函数。通过这种方式，可以让函数在后台异步执行，不会阻塞主线程的执行，提高程序的响应速度。

文章包含AI辅助创作，作者：Edit2，如若转载，请注明出处：https://docs.pingcode.com/baike/1072561

赞 (0)
Edit2Edit2
免费注册
电话联系

4008001024

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