C ++ 11线程修改std :: list

Question

我将发布我的代码，然后告诉您我在做什么。

#include <thread>
#include <mutex>
#include <list>
#include <iostream>

using namespace std;

...

//List of threads and ints
list<thread> threads;
list<int> intList;

//Whether or not a thread is running
bool running(false);

//Counters
int busy(0), counter(0);

//Add 10000 elements to the list
for (int i = 0; i < 10000; ++i){
    //push back an int
    intList.push_back(i);
    counter++;
    //If the thread is running, make a note of it and continue
    if (running){
        busy++;
        continue;
    }
    //If we haven't yet added 10 elements before a reset, continue
    if (counter < 10)
        continue;
    //If we've added more than 10 ints, and there's no active thread,
    //reset the counter and launch
    counter = 0;
    threads.push_back(std::thread([&]
        //These iterators are function args
        (list<int>::iterator begin, list<int>::iterator end){
        //mutex for the running bool
        mutex m;
        m.lock();
        running = true;
        m.unlock();

        //Remove either 10 elements or every element till the end
        int removed(0);
        while (removed < 10 && begin != end){
            begin = intList.erase(begin);
            removed++;
        }

        //unlock the running bool
        m.lock();
        running = false;
        m.unlock();
        //Pass into the thread func the current beginning and end of the list
    }, intList.begin(), intList.end()));
}

for (auto& thread : threads){
    thread.join();
}

我认为这段代码正在做的是在列表末尾添加10000个元素。 对于我们添加的每10个，启动一个（单个）线程，该线程将删除列表的前10个元素（在启动线程时）。

我不希望这会删除每个列表元素，我只是想看看在从开头删除元素的同时是否可以添加到列表的末尾。 在Visual Studio中，我经常会遇到“ list iterators incompatible ”错误，但我认为问题出在跨平台上。

我的想法怎么了？ 我知道是这样

编辑：

因此，我现在看到此代码非常不正确。 真的，我只希望一次激活一个辅助线程来删除元素，这就是为什么我尽管调用“擦除”是可以的。 但是，我不知道如何在不加入线程的情况下声明线程，如果我等待它，那么我真的看不到这样做的意义。

我应该在循环之前声明我的线程，让它等待主线程发出的信号吗？

为了明确起见，我的目标是执行以下操作：我想抓住一个线程上的键盘按键并将它们存储在列表中，并且每隔一段时间将它们记录到另一个线程上的文件中，同时删除我记录的内容。 由于我不想花很多时间写磁盘，因此我想写离散块（共10个）。

感谢克里斯托夫和其他所有人。 现在是我的代码...我可能没有正确使用lock_guard。

#include <thread>
#include <mutex>
#include <list>
#include <iostream>
#include <atomic>

using namespace std;

...

atomic<bool> running(false);
list<int> intList;
int busy(0), counter(0);
mutex m;
thread * t(nullptr);

for (int i = 0; i < 100000; ++i){
    //Would a lock_guard here be inappropriate?
    m.lock();
    intList.push_back(i);
    m.unlock();
    counter++;
    if (running){
        busy++;
        continue;
    }
    if (counter < 10)
        continue;
    counter = 0;
    if (t){
        t->join();
        delete t;
    }
    t = new thread([&](){
        running = true;

        int removed(0);
        while (removed < 10){
            lock_guard<mutex> lock(m);
            if (intList.size())
                intList.erase(intList.begin());  
            removed++;
        }
        running = false;
    });
}

if (t){
    t->join();
    delete t;
}

Answer 1

您的代码不适用于：

• 您的互斥锁对于每个线程都是本地的（每个线程都有它自己的副本，仅由它自己使用：没有线程间同步的机会！）
• intList不是原子类型，但是您可以从多个线程中访问它，从而导致竞争条件和未定义的行为。
• 在创建线程时发送给线程的开始和结束可能在执行期间不再有效。

这里有一些改进（请看注释行）：

atomic<bool> running(false);    // <=== atomic (to avoid unnecessary use of mutex)
int busy(0), counter(0);
mutex l;   // define the mutex here, so that it will be the same for all threads

for (int i = 0; i < 10000; ++i){
    l.lock();    // <===you need to protect each access to the list
    intList.push_back(i);
    l.unlock();  // <===and unlock 
    counter++;
    if (running){
        busy++;
        continue;
    }
    if (counter < 10)
        continue;
    counter = 0;
    threads.push_back(std::thread([&]
        (){    //<====No iterator args as they might be outdated during executionof threads!!
        running = true;    // <=== no longer surrounded from lock/unlock as it is now atomic

        int removed(0);
        while (removed < 10){
            l.lock();       // <====you really need to protect access to the list
            if (intList.size())    // <=== check if elements exist NOW
                intList.erase(intList.begin());  // <===use current data, not a prehistoric outdated local begin !!
            l.unlock();      // <====end of protected section
            removed++;
        }

        running = false;    // <=== no longer surrounded from lock/unlock as it is now atomic
    })); //<===No other arguments
}
...

顺便说一句，我建议您看一下lock_guard<mutex>中的锁，因为这些锁可以确保在所有情况下都可以解锁（尤其是在出现此类异常或意外惊喜时）。

编辑：通过使它成为atomic<bool> ，我避免了使用互斥锁running的锁定保护。