c++ - 如何使用 std::thread 逐行像素多线程？

Question

我想学习如何将我的多线程伪代码逐行修改为 C++。我理解伪代码，但我对 C++ 和 std::thread 函数都不是很有经验。

这是我经常使用的伪代码:

myFunction
{
    int threadNr=previous;
    int numberProcs = countProcessors();

    // Every thread calculates a different line
    for (y = y_start+threadNr; y < y_end; y+=numberProcs) {
        // Horizontal lines
        for (int x = x_start; x < x_end; x++) {
            psetp(x,y,RGB(255,128,0));
        }
    }
}

int numberProcs = countProcessors();

// Launch threads: e.g. for 1 processor launch no other thread, for 2 processors launch 1 thread, for 4 processors launch 3 threads
for (i=0; i<numberProcs-1; i++)
    triggerThread(50,FME_CUSTOMEVENT,i); //The last parameter is the thread number

triggerEvent(50,FME_CUSTOMEVENT,numberProcs-1); //The last thread used for progress

// Wait for all threads to finished
waitForThread(0,0xffffffff,-1);

我知道我可以通过 std::thread 使用一个线程调用我当前的函数，如下所示:

        std::thread t1(FilterImage,&size_param, cdepth, in_data, input_worldP, output_worldP);
        t1.join();

但这并不高效，因为它会在每个线程中一遍又一遍地调用整个函数。

我希望每个处理器都能自己处理一条水平线。

任何示例代码将不胜感激，因为我倾向于通过示例学习得最好。

Answer 1

调用thread::join() 强制调用线程等待子线程完成执行。例如，如果我用它在一个循环中创建多个线程，并在每个线程上调用 join()，它就好像一切都按顺序发生一样。

这是一个例子。我有两种方法可以打印出数字 1 到 n。第一个是单线程的，第二个是在创建线程时加入每个线程。 两者具有相同的输出，但线程化的速度较慢，因为您要等待每个线程完成才能开始下一个线程。

#include <iostream>
#include <thread>

void printN_nothreads(int n) {
    for(int i = 0; i < n; i++) {
        std::cout << i << "\n";
    }
}

void printN_threaded(int n) {
    for(int i = 0; i < n; i++) {
        std::thread t([=](){ std::cout << i << "\n"; });
        t.join(); //This forces synchronization
    }
}

更好地处理线程。

要从使用线程中获益，您必须在加入线程之前启动所有线程。此外，要避免 false sharing ，每个线程都应该在图像的单独区域上工作(理想情况下是内存中较远的部分)。

让我们看看它是如何工作的。我不知道您使用的是什么库，所以我将向您展示如何在 vector 上编写多线程转换。

auto transform_section = [](auto func, auto begin, auto end) {
    for(; begin != end; ++begin) {
        func(*begin);
    }
};

此transform_section 函数将在每个线程上调用一次，每个线程都位于 vector 的不同部分。让我们编写 transform 使其成为多线程的。

template<class Func, class T>
void transform(Func func, std::vector<T>& data, int num_threads) {
    size_t size = data.size(); 
    auto section_start = [size, num_threads](int thread_index) {
        return size * thread_index / num_threads; 
    };
    auto section_end = [size, num_threads](int thread_index) {
        return size * (thread_index + 1) / num_threads; 
    };

    std::vector<std::thread> threads(num_threads); 

    // Each thread works on a different section
    for(int i = 0; i < num_threads; i++) {
        T* start = &data[section_start(i)];
        T* end   = &data[section_end(i)]; 

        threads[i] = std::thread(transform_section, func, start, end);
    }

    // We only join AFTER all the threads are started
    for(std::thread& t : threads) {
        t.join();
    }
}