多线程编程C+-----第5课（封装一个父类，管理线程的生命（创建与销毁）并继承）

这里应该是实现线程池的基础，线程池是百万并发的基础，百万并发是赚一百分的基础（嘿嘿）。开个玩笑！

首先需要封装一个父类，Fthread{},其成员的组织如下：

1.首先private :
		std::thread th_; //线程对象
		virtual void Main() = 0 ; //线程函数，必须重写
		std::bool is_exit_ =false; //线程存活状态
2. 外部接口public:
		virtual void Star(){};线程开始
		virtual void Wait(){};//线程执行，直到结束并销毁；
		virtual void Stop(){};//线程销毁
		virtual void is_exist(){};//检测线程对象是否存活
	
然后使用public 继承，建立一个派生类（子类）sonthread{}:
	重写虚函数
		public: void Main() override {};//重写线程函数
	最后可以通过下面命令，进行该线程的创建、生活、消亡：
		sonthread tid;
		tid.Star();
		tid.Wait();
		tid.Stop();
		tid.is_exist();

// pthread.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <thread>
#include <windows.h>
#include <string>
using namespace std;

//创建一个管理线程的类，管理线程的创建与销毁（生命周期）
class Fthread {
    //父类管理者启动，给外部启动则放在public
public:
    virtual void Start() {
        th_ = std::thread(&Fthread::Main,this);
    };//线程启动(允许重写)

    virtual void Wait() {
        if (th_.joinable()) {
            th_.join();
        }
    }

    virtual void Stop() {
        is_exit_ = true;
        Wait();
    }

    bool is_exit() {
        return is_exit_;
    }
private:
    virtual void Main() = 0; //纯虚函数，子类必须实现Main(),该Main就是子线程的入口函数。
    std::thread th_;//使用std::thread 实例化一个对象th_,该对象就是子线程
    bool is_exit_ = false;
};

class sonthread:public Fthread {
    public:
        void Main() override {
            cout << "my tid:" << std::this_thread::get_id() << endl;
            while (!is_exit()) {
                std::this_thread::sleep_for(100ms);
                cout << "." << flush;
            }
        };
        string name;

};


int main()
{       
    sonthread tid;
    tid.Start();
    Sleep(3000);
    tid.Stop();
    return 0;
}