Запустите поток демона, который является частным методом класса?

Question

Я новичок в C++ 11 резьбы, и я пытаюсь сделать что-то выглядит следующим образом:

class Something { 
public: 
    void start() { 
     this->task_ = std::thread(&Something::someTask, this); 
     this->isRunning_ = true; 
     this->task_.detach(); // I read detach will stop it from hanging 
    } 

    void stop() { 
     this->isRunning = false; 
    } 

    ~Something() { 
     this->stop(); 
    }   

private: 
    std::atomic<bool> isRunning_; 
    std::thread task_; 
    void someTask() 
    { 
     while(this->isRunning_) { 
      // do something forever 
     } 
    } 
}; 

Something whatever; 
whatever.start(); 

Однако, поток продолжает получать заблокирован. Как ничто после whatever.start() выполняет. Он просто зависает во время цикла.

Answer 1

Обычная картина сделать это

class Something { 
public: 
    void start() { 
     this->task_ = std::thread(&Something::someTask, this); 
     // this->task_.detach(); <<<<<< Don't do that. 
    } 

    void stop() { 
     this->isRunning_ = false; 
     task_.join(); // <<< Instead of detaching the thread, join() it. 
    } 

    ~Something() { 
     this->stop(); 
    }   

private: 
    std::atomic<bool> isRunning_; 
    std::thread task_; 
    void someTask() 
    { 
     this->isRunning_ = true; 
     while(this->isRunning_) { 
      // do something forever 
     } 
    } 
}; 

---

Отсоединение std::thread обычно не является хорошей идеей, если нет какой-то синхронизации настройки, что позволяет ждать выполнения потока в до завершения процесса в целом.

---

Demonizing процесс обычно реализуется с fork(), чтобы создать дочерний процесс фона и оставить родительский процесс вернуть управление вызывающему.

Answer 2

Недавно я написал общий класс, который делает именно это

#include<functional> 
#include<thread> 

//do action asynchronously until condition is false 
class do_async_until{ 
public: 
    do_async_until(std::function<void(void)> action, 
        std::function<bool(void)> condition); 
    ~do_async_until(); 
    void start(); 
    void stop(); 
private: 
    void _do(); 
    std::thread _worker; 
    std::function<void(void)> _action; 
    std::function<bool(void)> _condition; 
}; 
//implementation 
do_async_until::do_async_until(std::function<void(void)> action, 
       std::function<bool(void)> condition):_action(action), 
            _condition(condition){ 
} 
do_async_until::~do_async_until(){ 
    stop(); 
} 
void do_async_until::start(){ 
    _worker = std::thread(std::bind(&do_async_until::_do,this)); 
} 
void do_async_until::stop(){ 
    if(_worker.joinable()){ 
     _worker.join(); 
    } 
} 
void do_async_until::_do(){ 
    while (_condition()) 
    { 
     _action(); 
    } 
} 

это будет запускать любую функцию с signiture пустоту (пустоты), пока условие функции BOOL (аннулируются) возвращает истинное

пример использования:

int main(int agrc,char** argv){ 
    bool running = true; 
    auto do_this = [](){ 
     std::cout<<"hello world"<<std::endl; 
    }; 
    auto condition = [&](){ 
     return running; 
    }; 
    do_async_until async(do_this,condition); 
    async.start(); 
    std::this_thread::sleep_for(std::chrono::seconds(1)); 
    running=false; 

    return 0; 
} 

Пример должен напечатать «привет мир» кучу раз в течение одной секунды, затем выйти.

EDIT: чтобы сделать эту работу с функцией члена просто нужно иметь экземпляр do_async_until внутри вас класса и передать функции члена конструктору do_async_until с помощью std::bind(&foo::func,this)