资讯

历史

科技

环境与自然

成长

游戏

财经

文学与艺术

美食

健康

家居

文化

情感

汽车

三农

军事

旅行

运动

教育

生活

星座命理

C语言并行计算：如何利用多核CPU

创作时间:

作者:

@小白创作中心

C语言并行计算：如何利用多核CPU

引用

来源

https://docs.pingcode.com/baike/1017258

C语言并行计算是充分利用多核CPU性能的关键技术。本文将详细介绍如何在C语言中利用多核CPU进行并行计算，包括使用线程、进程以及并行编程库等方法。通过本文的学习，读者将能够掌握C语言并行计算的基本原理和具体实现方式。

一、线程的使用

1. 线程基础

线程是操作系统中最小的执行单元，一个进程可以包含多个线程。每个线程共享进程的资源（如内存、文件描述符等），因此线程间的通信相对简单高效。

在C语言中，线程的创建和管理通常使用POSIX线程库（pthread）。该库提供了一组函数，用于创建、管理和同步线程。

2. 创建和管理线程

创建线程的基本步骤包括：定义线程函数、创建线程、等待线程结束。

#include <pthread.h>
#include <stdio.h>  
#include <stdlib.h>  

void* thread_function(void* arg) {  
    printf("Thread number: %dn", *(int*)arg);  
    return NULL;  
}  

int main() {  
    pthread_t threads[4];  
    int thread_args[4];  
    int result_code, index;  

    for (index = 0; index < 4; ++index) {  
        thread_args[index] = index;  
        result_code = pthread_create(&threads[index], NULL, thread_function, &thread_args[index]);  
        if (result_code) {  
            printf("Error creating thread %dn", index);  
            exit(EXIT_FAILURE);  
        }  
    }  

    for (index = 0; index < 4; ++index) {  
        result_code = pthread_join(threads[index], NULL);  
        if (result_code) {  
            printf("Error joining thread %dn", index);  
            exit(EXIT_FAILURE);  
        }  
    }  

    return 0;  
}

在这个例子中，我们创建了4个线程，每个线程执行thread_function。pthread_create函数用于创建线程，而pthread_join函数用于等待线程结束。

3. 线程同步

当多个线程需要访问共享资源时，必须保证访问的同步性。常见的同步机制包括互斥锁（mutex）和条件变量（condition variable）。

#include <pthread.h>
#include <stdio.h>  
#include <stdlib.h>  

pthread_mutex_t lock;  

void* thread_function(void* arg) {  
    pthread_mutex_lock(&lock);  
    printf("Thread number: %dn", *(int*)arg);  
    pthread_mutex_unlock(&lock);  
    return NULL;  
}  

int main() {  
    pthread_t threads[4];  
    int thread_args[4];  
    int result_code, index;  

    if (pthread_mutex_init(&lock, NULL)) {  
        printf("Mutex init failedn");  
        return 1;  
    }  

    for (index = 0; index < 4; ++index) {  
        thread_args[index] = index;  
        result_code = pthread_create(&threads[index], NULL, thread_function, &thread_args[index]);  
        if (result_code) {  
            printf("Error creating thread %dn", index);  
            exit(EXIT_FAILURE);  
        }  
    }  

    for (index = 0; index < 4; ++index) {  
        result_code = pthread_join(threads[index], NULL);  
        if (result_code) {  
            printf("Error joining thread %dn", index);  
            exit(EXIT_FAILURE);  
        }  
    }  

    pthread_mutex_destroy(&lock);  
    return 0;  
}

在这个例子中，我们使用互斥锁来保证线程对printf函数的访问是同步的，从而避免竞争条件。

二、进程的使用

1. 进程基础

进程是操作系统中资源分配的基本单位。每个进程有独立的内存空间和资源，因此进程间的通信相对复杂。

在C语言中，进程的创建和管理通常使用fork函数。该函数创建一个新进程，新进程是调用进程的副本。

2. 创建和管理进程

创建进程的基本步骤包括：调用fork函数、在父进程和子进程中分别执行不同的代码。

#include <stdio.h>
#include <stdlib.h>  
#include <unistd.h>  

int main() {  
    pid_t pid = fork();  

    if (pid < 0) {  
        printf("Fork failedn");  
        return 1;  
    } else if (pid == 0) {  
        printf("Child processn");  
    } else {  
        printf("Parent processn");  
        wait(NULL);  
    }  

    return 0;  
}

在这个例子中，fork函数创建一个新进程，pid为0表示子进程，pid大于0表示父进程，父进程使用wait函数等待子进程结束。

3. 进程间通信

进程间通信（IPC）机制包括管道（pipe）、共享内存（shared memory）和消息队列（message queue）等。

#include <stdio.h>
#include <stdlib.h>  
#include <unistd.h>  
#include <sys/wait.h>  

int main() {  
    int pipefd[2];  
    pid_t pid;  
    char buf;  

    if (pipe(pipefd) == -1) {  
        perror("pipe");  
        exit(EXIT_FAILURE);  
    }  

    pid = fork();  

    if (pid == -1) {  
        perror("fork");  
        exit(EXIT_FAILURE);  
    }  

    if (pid == 0) {    /* Child reads from pipe */  
        close(pipefd[1]);          /* Close unused write end */  
        while (read(pipefd[0], &buf, 1) > 0)  
            write(STDOUT_FILENO, &buf, 1);  
        close(pipefd[0]);  
        _exit(EXIT_SUCCESS);  
    } else {            /* Parent writes to pipe */  
        close(pipefd[0]);          /* Close unused read end */  
        write(pipefd[1], "Hello, world!n", 14);  
        close(pipefd[1]);          /* Reader will see EOF */  
        wait(NULL);                /* Wait for child */  
        exit(EXIT_SUCCESS);  
    }  
}

在这个例子中，父进程通过管道向子进程发送数据。

三、并行编程库的使用

1. OpenMP

OpenMP是一种用于多平台共享内存并行编程的API，支持C、C++和Fortran。通过在代码中插入编译指令，可以方便地实现并行计算。

2. 使用OpenMP实现并行计算

#include <omp.h>
#include <stdio.h>  
#include <stdlib.h>  

int main() {  
    int nthreads, tid;  

    #pragma omp parallel private(nthreads, tid)  
    {  
        tid = omp_get_thread_num();  
        printf("Hello from thread = %dn", tid);  

        if (tid == 0) {  
            nthreads = omp_get_num_threads();  
            printf("Number of threads = %dn", nthreads);  
        }  
    }  

    return 0;  
}

在这个例子中，#pragma omp parallel指令创建一个并行区域，所有线程执行并行区域中的代码。

3. OpenMP中的工作共享

OpenMP提供了多种工作共享指令，如#pragma omp for、#pragma omp sections等，用于在多个线程之间分配任务。

#include <omp.h>
#include <stdio.h>  
#include <stdlib.h>  
#define N 1000  

int main() {  
    int i, a[N], b[N], c[N];  

    #pragma omp parallel for  
    for (i = 0; i < N; i++) {  
        c[i] = a[i] + b[i];  
    }  

    return 0;  
}

在这个例子中，#pragma omp parallel for指令将循环中的迭代分配给多个线程执行，从而实现并行计算。