Question

I’ve recently started using lambdas an awful lot within threads, and want to make sure I’m not setting myself up for thread-safety issues/crashes later. My usual way of using them is:

class SomeClass {  
    int someid;  
    void NextCommand();  
    std::function<void(int, int)> StoreNumbers;  
    SomeClass(id, fn); // constructor sets id and storenumbers fn  
}

// Called from multiple threads  
static void read_callback(int fd, void* ptr)  
{  
    SomeClass* sc = static_cast<SomeClass*>ptr;  
    ..  
    sc->StoreNumbers(someint,someotherint); // voila, thread specific storage.  
}  

static DWORD WINAPI ThreadFn(LPVOID param)  
{  
    std::list<int> ints1;  
    std::list<int> ints2;  
    auto storenumbers = [&] (int i, int i2) {  
        // thread specific lambda.  
        ints1.push_back(i);  
        ints2.push_back(i2);  
        };  
    SomeClass s(id, storenumbers);  
    ...  
    // set up something that eventually calls read_callback with s set as the ptr. 
}  

ThreadFn is used as the thread function for 30-40 threads.

Is this acceptable? I usually have a few of these thread-specific lambdas that operate on a bunch of thread specific data.

Thank you!

Answer 1

There’s no problem here. A data access with a lambda is no different to a data access with a named function, through inline code, a traditional functor, one made with bind, or any other way. As long as that lambda is invoked from only one thread at a time, I don’t see any evidence of thread-related problems.