MFC多线程程序可以并行方式运行吗？

Question

I want to utilize multithread in MFC. I'm doing a little experiment to see if the program runs in a parallel method. I write two thread function like this:

UINT CMFCApplication2Dlg::thread01(LPVOID pParam)
{
    clock_t t1, t2;
    t1 = clock();
    for (int i = 0; i < 300000; i++)
        cout << "thread01111111111" << endl;

    t2 = clock();
    cout << "clock is " << t2 - t1 << endl;
    return 0;
}

UINT CMFCApplication2Dlg::thread02(LPVOID pParam)
{
    clock_t t1, t2;
    t1 = clock();

    for (int i = 0; i < 300000; i++)
        cout << "thread02222222222" << endl;


    t2 = clock();
    cout << "clock is " << t2 - t1 << endl;
    return 0;
}

and call them and output into a console window:

AllocConsole();                     

    freopen("CONOUT$", "w+t", stdout);

    freopen("CONIN$", "r+t", stdin);  

    printf("Hello World！\n");         

    CWinThread *pThread01;
    CWinThread *pThread02;
    pThread01 = AfxBeginThread(thread01, this, 0, 0, 0, NULL);
    pThread02 = AfxBeginThread(thread02, this, 0, 0, 0, NULL);

When running two threads together, the count is 118020; When running single thread, the count is 60315; When put two loops in the same thread in a serial way, I get 102795.

I used to think the compiler could optimize multiple-thread to execute in parallel automatically, but it seems like single core multithread concurrency does. It doesn't reduce runtime. The CPU I used has 4 cores. What should I do to run threads in different core parallel to achieve high performance?

Answer 1

Both threads are trying to use a shared resource ( std::cout ) at the same time. The system has to serialize output at one point so most of the time one of the threads will wait for the other one to finish writing. This is called synchronization . When you are using threads for performance improvements, you want to minimize the time spent for synchronization as much as possible, because during this time the threads can't do useful work.

Try to replace cout in the inner loop by a lengthy calculation, and only use cout at the end to print the final result, so the compiler cannot optimize the calculation away (without cout it could, because the calculation would have no observable effect).

Also, std::clock lacks precision for profiling. I recommend to use std::chrono::high_resolution_clock instead which usually is implemented using QueryPerformanceCounter() on the Windows platform. This is the best you can get on Windows.

Try this:

INT CMFCApplication2Dlg::thread01(LPVOID pParam)
{
    using myclock = std::chrono::high_resolution_clock;
    auto t1 = myclock::now();

    std::int64_t first = 0, second = 1, result = 0;
    for( std::int64_t i = 0; i < 10000000; ++i )
    {
         result = first + second;
         first = second;
         second = result;
    }

    auto t2 = myclock::now();   
    std::chrono::duration<double> td = t2 - t1;  // duration in seconds

    std::cout << "result is " << result << '\n'
              << "clock is " << std::fixed << std::setprecision( 6 ) << td.count() << " s" << std::endl;

    return 0;
}

Make sure the calculation is not too simple, because the optimizer is pretty clever and may turn your O(n) algorithm into O(1) for instance. It may even do the entire calculation at compile time and only assign a constant at runtime. To avoid that, you could read the number of loop iterations from cin instead. Though this wasn't necessary when testing the above code on MSVC 2017 even with full optimization.

Answer 2

Read about concurrency runtime. It can help you without the headache: https://msdn.microsoft.com/en-us/library/dd504870.aspx