Thinking Different




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#pragma once
 
#include <atomic>
#include <thread>
 
class Runnable
{
public:
    Runnable() : m_stop(), m_thread() { }
    virtual ~Runnable() { stop(); }
 
    Runnable(Runnable const&) = delete;
    Runnable& operator =(Runnable const&) = delete;
 
    void start() { m_thread = std::thread(&Runnable::run, this); }
    void stop() { m_stop = true; m_thread.join(); }
    void suspend() { SuspendThread(m_thread.native_handle()); }
    void resume() { ResumeThread(m_thread.native_handle()); }
    bool isStop() { return m_stop; }
 
protected:
    virtual void run() = 0;
 
private:
    std::atomic<bool> m_stop;
    std::thread m_thread;
};
 
class myThread : public Runnable
{
protected:
    void run() 
    {
        while (!m_stop)
        {
            /* do something... */
        };
    }
};
 
int _tmain(int argc, _TCHAR* argv[])
{
    myThread t;
    
    t.start();
    std::this_thread::sleep_for(std::chrono::milliseconds(1500));
 
    t.suspend();
    std::this_thread::sleep_for(std::chrono::milliseconds(1500));
 
    t.resume();
    std::this_thread::sleep_for(std::chrono::milliseconds(3500));
 
    t.stop();
 
    return 0;
}