using std::move in std::thread

Question

I encountered yet another problem with std::thread & this time while applying std::move to swap 2 values. My code says :-

#include <iostream>
#include <thread>
using namespace std;
void swapno (int &&a, int &&b)
{
    int temp=move(a);
    a=move(b);
    b=move(temp);
}
int main()
{
    int x=5, y=7;
    cout << "x = " << x << "\ty = " << y << "\n";
//  swapno (move(x), move(y));  // this works fine
    thread t (swapno, move(x), move(y));
    t.join();
    cout << "x = " << x << "\ty = " << y << "\n";
    return 0;
}

Output :-

x = 5   y = 7
x = 5   y = 7

Now what's wrong in this method ? Why is such the code showing such a behaviour ? How do I correct it ?

The thread use a copy of `x` and `y` not a ref to them. You can pass the pointer to `x` and `y` instead. — Jerome, Nov 24 '15 at 14:10
The reasons are the same as for your previous question. Also, use `std::swap`. — juanchopanza, Nov 24 '15 at 14:13
how did you go from "[you have to wrap it in an std::ref](http://stackoverflow.com/a/33895159)" to using &&? — default, Nov 24 '15 at 14:16
swapping of temporairies works @WernerErasmus, try the `swapno` function without a thread — Ankit Acharya, Nov 24 '15 at 14:37
After `std::move(x)` the variable `x` can't be use as rvalue since is value was move to another variable. — Jerome, Nov 24 '15 at 14:49

AndyG · Accepted Answer · 2015-11-24T15:17:17.563

3

It's because the thread constructor you're calling

copies/moves all arguments (both the function object f and all args...) to thread-accessible storage as if by the function:

template <class T>
typename decay<T>::type decay_copy(T&& v) {
    return std::forward<T>(v);
}

And std::decay will remove cv-qualifiers, which includes r-value references.

Thus, when std::thread is copy/moving arguments to thread-accessible storage, it's essentially move constructing it's own ints from the ones you provided, and because a move on an int is simply a copy, when you perform swapno on its values, you're doing it on copies.

To correct it, use std::ref plus swap:

std::thread t ([](int& a, int& b){std::swap(a, b);}, std::ref(x), std::ref(y));
t.join();

Live Demo

edited Nov 24 '15 at 15:17

answered Nov 24 '15 at 15:11

AndyG

39,700
8
109
143

so according to you we can't use `rvalue references` with `threads` ? – Ankit Acharya Nov 24 '15 at 15:37
1

@AnkitAcharya: Not exactly. You shouldn't use rvalue references when you want to access the data afterwards. In your case, `std::move` on an int is useless, but if you wanted to perhaps give the thread it's own `vector` to work on (which you constructed in the main thread), then `std::move`'ing that `vector` is useful. – AndyG Nov 24 '15 at 15:40

score 0 · Answer 2 · answered Nov 24 '15 at 15:25

In layman's terms, thread's constructor accepts temporaries/rvalues to the arguments passed to the function. Therefore you have to wrap it with a reference_wrapper, which is a value but wraps the underlying reference (what std::ref does).

The code below does the trick with std::swap out of the box. Using std::swap as argument to thread (or std::function) causes and ambiguous overload (which surprised me too).

int main(int argc, char* argv[])
{
  int x = 5, y = 7;
  std::cout << "x(" << x << ")" << " y(" << y <<")" << std::endl;
  void (*pf)(int& x, int& y) = std::swap<int>;
  std::thread t1(pf, std::ref<int>(x), std::ref<int>(y));
  t1.join();
  std::cout << "x(" << x << ")" << " y(" << y <<")" << std::endl;
  return 0;
}

using std::move in std::thread

2 Answers2