Question

我希望从并行运行线程访问基于STL的容器只读。不使用任何用户实现的锁定。以下代码的基础是C ++ 11，它具有适当的标准实现。

http://gcc.gnu.org/onlinedocs/libstdc++/manual/using_concurrency.html
http://www.sgi.com/tech/stl/thread_safety.html
http://www.hpl.hp.com/personal/Hans_Boehm/c++mm/threadsintro.html
http://www.open-std.org/jtc1/sc22/wg21/（current draft或N3337，其中主要是C ++ 11，错误较少，错别字更正了）

23.2.2集装箱数据竞赛[container.requirements.dataraces]

为了避免数据竞争（17.6.5.9），实现应该   将以下函数视为const：begin，end，rbegin，   rend，front，back，data，find，lower_bound，upper_bound，equal_range，   在和，除了关联或无序的关联容器，   运算符[]。

尽管如此（17.6.5.9），仍需要实施   当包含对象的内容时避免数据争用   除了矢量＆lt; bool＆gt;之外，相同序列中的不同元素是   同时修改。

[注意：对于矢量＆lt; int＆gt; x尺寸更大   比一个，x [1] = 5和* x.begin（）= 10可以同时执行   没有数据竞争，但执行了x [0] = 5和* x.begin（）= 10   同时可能导致数据竞争。作为一般的例外   规则，对于向量＆lt; bool＆gt; y，y [0] = true可能与y竞争[1]   =真。 - 结束说明]

和

17.6.5.9数据竞争规避[res.on.data.races] 1本节规定了实施应满足的要求以防止数据   比赛（1.10）。每个标准库函数都应满足每个要求   要求除非另有规定。实施可能会阻止   在下面指定的情况下的数据争用。

2 C ++标准   库函数不得直接或间接访问对象   （1.10）可以通过当前线程以外的线程访问，除非   通过函数直接或间接访问对象   争论，包括这个。

3 C ++标准库函数必须   不直接或间接修改线程可访问的对象（1.10）   除了当前线程，除非直接访问对象   或间接通过函数的非const参数，包括   此

4 [注意：这意味着，例如，实现不能   将静态对象用于内部目的而不进行同步   因为即使在没有数据竞争的程序中也可能导致数据竞争   在线程之间显式共享对象。 - 结束说明]

5 C ++标准库函数不得间接访问对象   可通过其参数或其容器的元素访问   参数除了通过调用其规范所需的函数   在那些容器元素上。

6对迭代器的操作   调用标准库容器或字符串成员函数可以   访问底层容器，但不得修改它。 [注意：在   特别是，使迭代器无效的容器操作冲突   对与该容器关联的迭代器的操作。 - 结束   注意]

7实现可以在它们之间共享自己的内部对象   如果对象对用户不可见并受到保护，则为线程   反对数据竞赛。

8除非另有说明，否则为C ++标准库   功能应仅在当前内执行所有操作   线程，如果这些操作具有可见的效果（1.10）   用户。

9 [注意：这允许实现并行化操作   如果没有明显的副作用。 - 结束说明]

结论
容器不是线程安全的！但是在多个并行线程的容器上调用 const函数是安全的。因此，可以在没有锁定的情况下从并行线程执行只读操作。我是对的吗？

我假装它们不存在任何错误的实现，并且C ++ 11标准的每个实现都是正确的。

样品：

// concurrent thread access to a stl container
// g++ -std=gnu++11 -o p_read p_read.cpp -pthread -Wall -pedantic && ./p_read
#include <iostream>
#include <iomanip>
#include <string>
#include <unistd.h>

#include <thread>
#include <mutex>

#include <map>

#include <cstdlib>
#include <ctime>
using namespace std;

// new in C++11
using str_map = map<string, string>;

// thread is new in C++11
// to_string() is new in C++11

mutex m;
const unsigned int MAP_SIZE = 10000;

void fill_map(str_map& store) {
    int key_nr;
    string mapped_value;
    string key;

    while (store.size() < MAP_SIZE) {
        // 0 - 9999
        key_nr = rand() % MAP_SIZE;

        // convert number to string
        mapped_value = to_string(key_nr);
        key = "key_" + mapped_value;

        pair<string, string> value(key, mapped_value);
        store.insert(value);
    }
}

void print_map(const str_map& store) {
    str_map::const_iterator it = store.begin();

    while (it != store.end()) {
        pair<string, string> value = *it;
        cout << left << setw(10) << value.first << right << setw(5) << value.second << "\n";
        it++;   
    }
}

void search_map(const str_map& store, int thread_nr) {
    m.lock();
    cout << "thread(" << thread_nr << ") launched\n";
    m.unlock();

    // use a straight search or poke around random
    bool straight = false;
    if ((thread_nr % 2) == 0) {
        straight = true;
    }

    int key_nr;
    string mapped_value;
    string key;
    str_map::const_iterator it;

    string first;
    string second;

    for (unsigned int i = 0; i < MAP_SIZE; i++) {

        if (straight) {
            key_nr = i;
        } else {
            // 0 - 9999, rand is not thread-safe, nrand48 is an alternative             
            m.lock();
            key_nr = rand() % MAP_SIZE;
            m.unlock();
        }

        // convert number to string
        mapped_value = to_string(key_nr);
        key = "key_" + mapped_value;

        it = store.find(key);

        // check result
        if (it != store.end()) {
            // pair
            first = it->first;
            second = it->second;

            // m.lock();
            // cout << "thread(" << thread_nr << ") " << key << ": "
            //      << right << setw(10) << first << setw(5) << second << "\n"; 
            // m.unlock();

            // check mismatch
            if (key != first || mapped_value != second) {
                m.lock();
                cerr << key << ": " << first << second << "\n"
                     << "Mismatch in thread(" << thread_nr << ")!\n";
                exit(1);

                // never reached
                m.unlock();
            }
        } else {
            m.lock();
            cerr << "Warning: key(" << key << ") not found in thread("
                 << thread_nr << ")\n";
            exit(1);

            // never reached
            m.unlock();
        }
    }
}

int main() {
    clock_t start, end;
    start = clock();

    str_map store;
    srand(0);

    fill_map(store);
    cout << "fill_map finished\n";

    // print_map(store);
    // cout << "print_map finished\n";

    // copy for check
    str_map copy_store = store;

    // launch threads
    thread t[10];
    for (int i = 0; i < 10; i++) {
        t[i] = thread(search_map, store, i);
    }

    // wait for finish
    for (int i = 0; i < 10; i++) {
        t[i].join();
    }
    cout << "search_map threads finished\n";

    if (store == copy_store) {
        cout << "equal\n";
    } else {
        cout << "not equal\n";
    }


    end = clock();
    cout << "CLOCKS_PER_SEC " << CLOCKS_PER_SEC << "\n";
    cout << "CPU-TIME START " << start << "\n";
    cout << "CPU-TIME END " << end << "\n";
    cout << "CPU-TIME END - START " << end - start << "\n";
    cout << "TIME(SEC) " << static_cast<double>(end - start) / CLOCKS_PER_SEC << "\n";

    return 0;
}

此代码可以使用 GCC 4.7 进行编译，并在我的计算机上正常运行。

$ echo $？
$ 0

Answer 1

数据竞争，从1.10 / 4和1.10 / 21节中的C ++ 11规范，至少需要两个线程对同一组内存位置进行非原子访问，这两个线程不同步关于访问一组内存位置，以及至少一个线程写入或修改内存位置集中的元素。所以在你的情况下，如果线程只是读取，你很好......根据定义，因为没有一个线程写入同一组内存位置，即使没有明确的同步机制，也没有数据争用。线程。

Answer 2

是的，你是对的。只要填充向量的线程在读取器线程开始之前完成，就是安全的。最近有a similar question。

对STL容器的安全并行只读访问

2 个答案: