Thread-safety of using unique_ptr inside lambda when creating new thread

Question

I would like to know if the following code is thread-safe

void use_value(int i, unique_ptr<vector<int>> v);
for (int i = 0; i < 10; i++){
    unique_ptr<vector<int>> ptr = make_unique<vector<int>>(10);
    // ...
    // Here, the vector pointed to by ptr will be filled with specific values for each thread.
    // ....
    thread(
        [i, &ptr](){
            use_value(i, move(ptr));
        }
    );
}

Thank you

Perhaps this is not your real code, but this example program will terminate after the first iteration of the loop, as the `std::thread` is [destroyed while still in a joinable state](http://en.cppreference.com/w/cpp/thread/thread/~thread). — Oktalist, Aug 07 '16 at 13:34
@Oktalist you are right, it is not the real code; but I got interested in the point. You mean the newly created thread, because of RAII? — Ahmad Siavashi, Aug 07 '16 at 20:52
`std::thread` is not a thread, it manages a thread. `thread([i, &ptr](){use_value(i, move(ptr));});` constructs a temporary `std::thread` which is immediately destroyed after the last `;`. Destroying an initialized `std::thread` without first calling `join()` or `detach()` will result in premature program termination. You need to move (or emplace construct) the `std::thread` somewhere else so it's not immediately destroyed, which is what your real code presumably already does. — Oktalist, Aug 08 '16 at 14:03

score 4 · Accepted Answer · edited May 23 '17 at 12:22

4

It's undefined behavior. You don't know when the lambda body will be called. So that ptr you capture by reference can very well be out of scope by then, the resource destructed, and you are left with a dangling reference.

You should "move-capture" the ptr (or better yet, just the vector) into the lambda, if you have access to c++14.

If you move (or copy) the vector, your code will be thread safe.

edited May 23 '17 at 12:22

Community

1
1

answered Aug 07 '16 at 12:03

StoryTeller - Unslander Monica

165,132
21
377
458

Just a nit: this is about lifetime, not scope. – Aug 07 '16 at 12:06
@AhmadSiavashi, only the reference is captured on lambda creation. The body may be called at any time when `std::thread` is involved. – StoryTeller - Unslander Monica Aug 07 '16 at 12:07
@hvd, You are very much correct. But I had to address this sort of glaring mistake first. – StoryTeller - Unslander Monica Aug 07 '16 at 12:07
@StoryTeller yes, but unfortunately I'm using MSVC++ 2013. You now about it and the messy workarounds that have been suggested. – Ahmad Siavashi Aug 07 '16 at 12:08
@StoryTeller If I copy the vector using unique_ptr will be meaningless. Am I right? – Ahmad Siavashi Aug 07 '16 at 12:10
1

@AhmadSiavashi, `std::unique_ptr` isn't copyable, only moveable. If you don't mind a little overhead (and "little" depends on the size of your vector), you can substitute `std::shared_ptr` for it, and copy that. – StoryTeller - Unslander Monica Aug 07 '16 at 12:11
@StoryTeller You are right, but the size of the vector varies greatly. I'm still thinking of workarounds. The problem is with Microsoft's implementation of standard libraries. One cannot use 'std::move' along 'std::async' or 'thread' – Ahmad Siavashi Aug 07 '16 at 12:16
1

@AhmadSiavashi I suggest you write correct code first, and optimize second. The overhead may end up being negligable. – StoryTeller - Unslander Monica Aug 07 '16 at 12:19
@StoryTeller Yes, that's probably the main option beside upgrading MSVC and migrating to c++14. Thank you. – Ahmad Siavashi Aug 07 '16 at 12:25
It seems rather than a vector being passed in standard 'scatter/gather' type approach is the solution. Is there a reason you are storing the parameters in a vector at all? – William Jones Aug 07 '16 at 12:36
@WilliamJones, you should comment that on the original post (or tag the persion who opened the question by prepending `@` to their name.) Otherwise only I get notified about it, since this is my answer. – StoryTeller - Unslander Monica Aug 07 '16 at 12:56

Thread-safety of using unique_ptr inside lambda when creating new thread

1 Answers1