多线程学习地址

https://www.kancloud.cn/jxm_zn/cpp_concurrency_in_action/content
csdn:https://www.cnblogs.com/haippy/p/3284540.html
常用框架代码：
头文件：ThreadAlloc.h

#pragma once
#include<iostream>
#include <thread>
#include <atomic>
#include <vector>
#include <functional>

namespace EPT {

	inline uint64_t get_current_timestamps() {
		return std::chrono::steady_clock::now().time_since_epoch().count();
	}
}

class WorkThread {
public:
	WorkThread() = default;
	WorkThread(std::function<void(void)> _func,int _frameCount=50);
	~WorkThread() = default;
	void init_thread_resource();
	void release_resource();
private:
	void _worker_thread();

private:
	std::atomic_bool done{false};
	std::thread _threads;
	uint64_t _last_delta_time = 0;
	int m_cframeCount;
	std::function<void(void)> m_func;
};

实现文件:ThreadAlloc.cpp

#include "ThreadAlloc.h"

//constexpr int cframetime = 50;

WorkThread::WorkThread(std::function<void(void)> _func,int _frameCount)
{
	m_func = _func;
	m_cframeCount = _frameCount;
}

void WorkThread::init_thread_resource()
{
	std::thread tem_thread = std::thread(std::bind(&WorkThread::_worker_thread, this));
	_threads.swap(tem_thread);
}

void WorkThread::release_resource()
{
	done.store(true, std::memory_order_release);

	if (_threads.joinable()) 
	{
		_threads.join();
	}
}

void WorkThread::_worker_thread()
{
	while (!done) 
	{
		uint64_t _execute_start = EPT::get_current_timestamps();
		
		//Working
		if (m_func)
		{
			m_func();
		}
		else
		{
			std::cout << "m_func is null" << std::endl;
		}
		uint64_t _execute_end = EPT::get_current_timestamps();
		uint64_t _last_elapse = (_execute_end - _execute_start) / 1000000;

		if (_last_elapse < m_cframeCount)
		{
			std::this_thread::sleep_for(std::chrono::milliseconds(m_cframeCount - _last_elapse)); //߳ѭƵ
			_last_delta_time = m_cframeCount;
		}
		else 
		{
			_last_delta_time = _last_elapse;
		}
	}
}