是否需要 mutex(） 来安全地同时访问具有 2 个线程的数组的不同元素?

是否需要 mutex(( 来安全地同时访问具有 2 个线程的数组的不同元素？

如果不写入可能同时写入或由另一个线程读取的元素，则不需要互斥锁。

程序不会崩溃，但完成后数组中缺少数据

正如@G.M.所暗示的那样，您应该只在一个范围内拆分(在这种情况下是X(，否则您将只处理一半的单元格。一个线程处理 1/4，另一个线程处理 1/4。您应该在 X 上拆分，因为您希望每个线程处理的数据尽可能靠近。

请注意，2D 数组中的数据以行主顺序存储在内存中(这就是为什么人们通常使用[Y][X]表示法的原因(，但也可以像您一样做。在X上拆分会给一个线程一半的内存行，另一个线程提供另一半的内存行。

另一种方法是不自己进行线程管理。C++17 添加了执行策略，允许您编写循环，其中循环主体可以在不同的线程中执行，通常从内部线程池中选取。将使用多少线程取决于C++实现和执行程序的硬件。

我做了一个例子，我交换了 X 和 Y，并对你正在使用的实际类型做了一些假设，我已经为它们创建了别名。

#include <algorithm> // std::for_each
#include <array>
#include <execution> // std::execution::par
#include <iostream>
#include <memory>
#include <type_traits>
// a class to keep everything together
struct conus {
static constexpr size_t y_size = 520, x_size = 1180;
// row aliases
using conus_int_row_t = std::array<int, x_size>;
using conus_bool_row_t = std::array<bool, x_size>;
using conus_real_row_t = std::array<double, x_size>;
// 2D array aliases
using conus_grid_int_t = std::array<conus_int_row_t, y_size>;
using conus_grid_bool_t = std::array<conus_bool_row_t, y_size>;
using conus_grid_real_t = std::array<conus_real_row_t, y_size>;
// a class to store the arrays
struct conus_data_t {
conus_grid_int_t conus_grid{};
conus_grid_bool_t grid_used{};
conus_grid_real_t conus_grid_west{}, conus_grid_east{},
conus_grid_north{}, conus_grid_south{};
// an iterator to be able to loop over the row number in the arrays
class iterator {
public:
using iterator_category = std::forward_iterator_tag;
using value_type = unsigned;
using difference_type = std::make_signed_t<value_type>;
using pointer = value_type*;
using reference = value_type&;
iterator(unsigned y = 0) : current(y) {}
iterator& operator++() {
++current;
return *this;
}
bool operator!=(const iterator& rhs) const {
return current != rhs.current;
}
unsigned operator*() { return current; }
private:
unsigned current;
};
// create iterators to use in loops
iterator begin() { return {0}; }
iterator end() { return {static_cast<unsigned>(conus_grid.size())}; }
};
// create arrays on the heap to save the stack
std::unique_ptr<conus_data_t> data = std::make_unique<conus_data_t>();
void writeCell(double lat, double lon, int energy) {
// Below is the std::execution::parallel_policy in use.
// A lambda, capturing its surrounding by reference, is called for each "y".
std::for_each(std::execution::par, data->begin(), data->end(), [&](unsigned y) {
// here we're most probably in a thread from the thread pool
// references to the rows
conus_int_row_t& row_grid = data->conus_grid[y];
conus_bool_row_t& row_used = data->grid_used[y];
conus_real_row_t& row_west = data->conus_grid_west[y];
conus_real_row_t& row_east = data->conus_grid_east[y];
conus_real_row_t& row_north = data->conus_grid_north[y];
conus_real_row_t& row_south = data->conus_grid_south[y];
for(unsigned x = 0; x < x_size; ++x) {
// Check every cell for one that matches current lat
// and lon selection, then write into that cell.
if(lon < row_west[x] && lon > row_east[x] &&
lat < row_north[x] && lat > row_south[x])
{
row_used[x] = true;
// this is where it accesses the array
row_grid[x] += energy;
}
}
});
}
};

如果在 Linux 上使用g++或clang++，则必须与tbb链接(链接时添加-ltbb(。其他编译器可能具有其他库需求才能使用执行策略。Visual Studio 2019 会立即编译并链接它，如果您选择 C++17 作为您的语言。

我经常发现使用std::execution::par是一种快速且半简单的方法来加快速度，但您必须自己尝试一下，看看它是否会在您的目标机器上变得更快。