dl_thread.h

浏览该文件的文档.

#pragma once
 
#include <list>
#include <functional>
#include <thread>
#include <cassert>
#include <atomic>
 
#include "io/dl_log.h"
 
namespace dl
{
 
// 状态 -1未开始 0执行中 1结束
// Start    -1 -> 0
// 完成       0 -> 1
// Clear    1 -> -1

class Thread
{
    friend class ThreadManager;
public:
    void Start(std::function<void(void*)> func, void* user_data)
    {
        if (_state != -1)
        {
            log_err("线程不是初始状态，不能再次运行！");
            return;
        }
        _func = func;
        _userData = user_data;
        _t = std::thread{ _run, this };
        _t.detach();
    }
    void Clear()
    {
        if (_state == -1)
            return;
        if (_state == 0)
        {
            log_err("线程未完成，不能重置状态！");
            return;
        }
        _state = -1;
        _func = nullptr;
        _userData = nullptr;
    }
    // 强行结束
    void Terminate();
 
    int GetState() { return _state; }
    bool IsWork() { return _state == 0; }
    bool IsFinish() { return _state == 1; }
    ~Thread();
private:
    Thread() :
        _state{ -1 },
        _userData{ nullptr }
    {}
 
    std::atomic_int _state;// -1未开始 0执行中 1结束
    std::function<void(void*)> _func;
    std::thread _t;
    void* _userData;
    static void _run(Thread* t)
    {
        t->_state = 0;
        t->_func(t->_userData);
        t->_state = 1;
    }
};
 
// 线程管理
// 1.创建线程对象
// 2.运行线程（传入函数、自定义数据）
// 3.删除线程对象

class ThreadManager
{
public:
    Thread* Create()
    {
        Thread* ret = new Thread;
        _allThread.push_back(ret);
        return ret;
    }
    ThreadManager()
    {}
    ~ThreadManager()
    {
    }
 
    void _remove_ref(Thread* t)
    {
        auto iter = std::find(_allThread.begin(), _allThread.end(), t);
        if (iter == _allThread.end())
        {
            assert(0);
            return;
        }
        _allThread.erase(iter);
    }
private:
    std::list<Thread*> _allThread;
};
extern ThreadManager* g_thread;
}