multi-thread

拖了这么久，终于才开始搞多线程。

毕设中用的算法是GA+Local Search（memetic），算法时间太长，而local search部分花费了大量的时间，于是考虑用多线程的方法来加快该步骤的计算速度。

找到一个入门教程（C++ 多线程 | 菜鸟教程 (runoob.com)），是windows平台下的多线程使用，需要包含头文件 <windows.h>，其中创建新的线程是用CreateThread(参数, ...)；而C++11提供了封装线程相关操作的库，只需要包含头文件<thread>，"std::thread 变量名" 即可创建一个线程，而且是跨平台的。

看到一篇帖子讲到，临界区比互斥量快得多，因为临界区是用户态下，互斥量需要切换到核心态下。帖子如下：

(32条消息) C++11 std::thread 与 windows 运行库API _beginthreadex ；C++11 std::mutex 与 CriticalSection 的对比_chenjian60665的博客-CSDN博客

 

#include <windows.h>
#include <iostream>
#include <omp.h>
#include<mutex>
#include<thread>
#include <ctime>

using namespace std;

#define NAME_LINE 40

mutex mtx;
volatile clock_t startt, endt;

// 定义线程函数传入参数的结构体
typedef struct _THREAD_DATA
{
    int nMaxNum;
    char strThreadName[NAME_LINE];

    _THREAD_DATA() : nMaxNum(0)
    {
        memset(strThreadName, 0, NAME_LINE * sizeof(char));
    }

} THREAD_DATA;    

HANDLE g_hMutex = NULL; // 互斥量

void mysleep() {
    Sleep(1000);
}

// 线程函数
DWORD WINAPI ThreadProc(LPVOID lpParameter) {
    THREAD_DATA* pThreadData = (THREAD_DATA*)lpParameter;

    for (int i = 0; i < pThreadData->nMaxNum; ++i) {
        // 请求获得一个互斥量锁
        //WaitForSingleObject(g_hMutex, INFINITE);
        cout << pThreadData->strThreadName<<"---" << i <<endl;
        mysleep();
        // 释放互斥量锁 
        //ReleaseMutex(g_hMutex);
    }
    endt = clock();
    double endtime = (double)(endt - startt) / CLOCKS_PER_SEC;

    cout << "Total time:" << endtime << endl;        //s为单位
    //cout << "Total time:" << endtime * 1000 << "ms" << endl;    //ms为单位

    return 0L;
}

int main() 
{

    // 创建一个互斥量
    g_hMutex = CreateMutex(NULL, FALSE, NULL);

    mtx.try_lock();
    startt = clock();

    // pragma omp parallel for
    // 
    // 初始化线程数据
    THREAD_DATA threadData1, threadData2, threadData3, threadData4;
    threadData1.nMaxNum = 10;
    strcpy_s(threadData1.strThreadName, "线程1");
    threadData2.nMaxNum = 10;
    strcpy_s(threadData2.strThreadName, "线程2");
    threadData3.nMaxNum = 10;
    strcpy_s(threadData3.strThreadName, "线程3");
    threadData4.nMaxNum = 10;
    strcpy_s(threadData4.strThreadName, "线程4");
    
    THREAD_DATA threadData5, threadData6, threadData7, threadData8, threadData9;
    threadData5.nMaxNum = 10;
    strcpy_s(threadData5.strThreadName, "线程5");
    threadData6.nMaxNum = 10;
    strcpy_s(threadData6.strThreadName, "线程6");
    threadData7.nMaxNum = 10;
    strcpy_s(threadData7.strThreadName, "线程7");
    threadData8.nMaxNum = 10;
    strcpy_s(threadData8.strThreadName, "线程8");
    threadData9.nMaxNum = 10;
    strcpy_s(threadData9.strThreadName, "线程9");

    //主线程的执行路径
    // 创建第一个子线程
    HANDLE hThread1 = CreateThread(NULL, 0, ThreadProc, &threadData1, 0, NULL);
    // 创建第二个子线程
    HANDLE hThread2 = CreateThread(NULL, 0, ThreadProc, &threadData2, 0, NULL);
    // 创建第三个子线程
    HANDLE hThread3 = CreateThread(NULL, 0, ThreadProc, &threadData3, 0, NULL);
    // 创建第三个子线程
    HANDLE hThread4 = CreateThread(NULL, 0, ThreadProc, &threadData4, 0, NULL);

    // 创建第一个子线程
    HANDLE hThread5 = CreateThread(NULL, 0, ThreadProc, &threadData5, 0, NULL);
    // 创建第二个子线程
    HANDLE hThread6 = CreateThread(NULL, 0, ThreadProc, &threadData6, 0, NULL);
    // 创建第三个子线程
    HANDLE hThread7 = CreateThread(NULL, 0, ThreadProc, &threadData7, 0, NULL);
    // 创建第三个子线程
    HANDLE hThread8 = CreateThread(NULL, 0, ThreadProc, &threadData8, 0, NULL);
    // 创建第三个子线程
    HANDLE hThread9 = CreateThread(NULL, 0, ThreadProc, &threadData9, 0, NULL);

    // 关闭线程
    CloseHandle(hThread1);
    CloseHandle(hThread2);
    CloseHandle(hThread3);
    CloseHandle(hThread4);
    CloseHandle(hThread5);
    CloseHandle(hThread6);
    CloseHandle(hThread7);
    CloseHandle(hThread8);
    CloseHandle(hThread9);

    /*
    //主线程的执行路径
    for (int i = 0; i < 5; ++i) {
        // 请求获得一个互斥量
        WaitForSingleObject(g_hMutex, INFINITE);
        cout << "主线程===" << i << endl;
        Sleep(100);
        // 释放互斥量锁
        ReleaseMutex(g_hMutex);
    }
    */

    mtx.unlock();
    endt = clock();
    double endtime = (double)(endt - startt) / CLOCKS_PER_SEC;

    cout << "Total time:" << endtime << endl;        //s为单位
    cout << "Total time:" << endtime * 1000 << "ms" << endl;    //ms为单位

    system("pause");

    return 0;
}