通过写入外部变量来取消c ++线程是安全/有效的吗？

Question

I have a search problem, which I want to parallelize. If one thread has found a solution, I want all other threads to stop. Otherwise, if all threads exit regularly, I know, that there is no solution.

The following code (that demonstrates my cancelling strategy) seems to work, but I'm not sure, if it is safe and the most efficient variant:

#include <iostream>
#include <thread>
#include <cstdint>
#include <chrono>

using namespace std;

struct action {
  uint64_t* ii;

  action(uint64_t *ii) : ii(ii) {};

  void operator()() {
    uint64_t k = 0;
    for(; k < *ii; ++k) {
      //do something useful
    }
    cout << "counted to " << k << " in 2 seconds" << endl;
  }
  void cancel() {
    *ii = 0;
  }
};


int main(int argc, char** argv) {
  uint64_t ii = 1000000000;
  action a{&ii};
  thread t(a);
  cout << "start sleeping" << endl;
  this_thread::sleep_for(chrono::milliseconds(2000));
  cout << "finished sleeping" << endl;
  a.cancel();
  cout << "cancelled" << endl;
  t.join();
  cout << "joined" << endl;
}

Can I be sure, that the value, to which ii points, always gets properly reloaded? Is there a more efficient variant, that doesn't require the dereferenciation at every step? I tried to make the upper bound of the loop a member variable, but since the constructor of thread copies the instance of action , I wouldn't have access to that member later.

Also: If my code is exception safe and does not do I/O (and I am sure, that my platform is Linux), is there a reason not to use pthread_cancel on the native thread?

Answer 1

No, there's no guarantee that this will do anything sensible. The code has one thread reading the value of ii and another thread writing to it, without any synchronization. The result is that the behavior of the program is undefined.

I'd just add a flag to the class:

std::atomic<bool> time_to_stop;

The constructor of action should set that to false , and the cancel member function should set it to true . Then change the loop to look at that value:

for(; !time_to_stop && k < *ii; ++k)

You might, instead, make ii atomic. That would work, but it wouldn't be as clear as having a named member to look at.

Answer 2

First off there is no reason to make ii a pointer. You can have it just as a plain uint64_t .

Secondly if you have multiple threads and at least one of them writes to a shared variable then you are going to have to have some sort of synchronization. In this case you could just use std::atomic<uint64_t> to get that synchronization. Otherwise you would have to use a mutex or some sort of memory fence.