可以考虑把数据分段 多线程运算， 每个线程运算一段

并行计算。。。。。。。。。。。。。。。。

可以考虑把数据分段 多线程运算， 每个线程运算一段，好麻烦

除了多线程，还可以考虑SIMD，支持的话可以用AVX指令，下面是多线程的

#include <Windows.h>

#include <malloc.h>

typedef struct _MyParameter

{

    double *A, *B, *C;

    int start, length;

}MyParameter, *PMyParameter;



DWORD multiply_thread(PVOID pv)

{

    PMyParameter p = (PMyParameter)pv;

    for (int i = p->start; i < p->start + p->length; ++i)

    {

        p->C[i] = p->A[i] * p->B[i];

    }

    return 0;

}



void multiply(double *A, double *B, double *C, int length)

{

    SYSTEM_INFO system_info;

    GetSystemInfo(&system_info);

    //线程数为逻辑CPU数目2倍

    int numberOfThreads = system_info.dwNumberOfProcessors * 2;

    //线程句柄数组

    PHANDLE handles = (PHANDLE)malloc(sizeof(HANDLE) * numberOfThreads);

    if (handles == NULL)

    {

        return;

    }

    //参数数组

    PMyParameter parameters = (PMyParameter)malloc(sizeof(MyParameter) * numberOfThreads);

    if (parameters == NULL)

    {

        return;

    }

    //每线程计算长度

    int lengthPerThread = length / numberOfThreads;

    MyParameter parameter = { A,B,C,0,lengthPerThread };

    //多线程计算

    for (int i = 0; i < numberOfThreads; ++i)

    {

        parameters[i] = parameter;

        parameters[i].start = i * lengthPerThread;

        handles[i] = CreateThread(NULL, 0, multiply_thread, parameters + i, NULL, NULL);

    }

    for (int i = length / numberOfThreads * numberOfThreads; i < length; ++i)

    {

        C[i] = A[i] * B[i];

    }

    WaitForMultipleObjects(numberOfThreads, handles, TRUE, INFINITE);

    free(handles);

    free(parameters);

}

 for (int i = length / numberOfThreads * numberOfThreads; i < length; ++i)
    {
        C[i] = A[i] * B[i];
    }


length / numberOfThreads * numberOfThreads
这里是笔误么？

並行計算是最好的方法。

分段，分段数为CPU核心数的1~2倍，这样效率比较高