3.6 视频服务器-服务器层实现

先顶层的，再具体功能的
良好的封装可以提升开发效率（线程安全的队列、线程、线程池）
服务器实现

线程安全队列
 template<class T>//T是我们直接决定
class TianChenQueue
{//线程安全的队列,(利用IOCP实现)
public:
	enum
	{
		TCNone,
		TCPush,
		TCPop,
		TCSize,
		TCClear,
	};
	typedef struct IocpParam
	{
		size_t nOperator;//操作
		T Data;//数据
		HANDLE hEvent;//pop需要的
		IocpParam(int op, const T& data, HANDLE hEve = NULL) {
			nOperator = op;
			Data = data;
			hEvent = hEve;
		}
		IocpParam() {
			nOperator = TCNone;
		}
	}PARAM;//Post Parameter 用于投递信息的结构体
public:
	TianChenQueue() 
   {
		m_lock = false;
		m_hCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 1);//写一个线程
		m_hTread = INVALID_HANDLE_VALUE;
		if (m_hCompletionPort != NULL) {//
			m_hTread = (HANDLE)_beginthread(&TianChenQueue<T>::thradEntry, 0, this); //arglist线程的参数
		}
	};
	virtual ~TianChenQueue()
	{
		if (m_lock == true)return;
		m_lock = true;
		PostQueuedCompletionStatus(m_hCompletionPort, 0, NULL, NULL);//强制传一个状态结束
		WaitForSingleObject(m_hTread, INFINITE);
		if (m_hCompletionPort != NULL) {
			HANDLE hTemp = m_hCompletionPort;
			m_hCompletionPort = NULL;
			CloseHandle(hTemp);
		}
	};
	bool PushBack(const T& data){}
	virtual bool PopFront(T& data) {}
	
	size_t Size() {}
	bool Clear() {
}
protected:
	static void thradEntry(void* arg) {
}
	virtual void DealParam(PARAM* pParam)
	
{}	
	virtual void threadMain()
{}
protected:
	std::list<T> m_lstData;
	HANDLE m_hCompletionPort;
	HANDLE m_hTread;
	std::atomic<bool> m_lock;//队列正在析构
};

template<class T>
class TianchenSendQueue :public TianChenQueue<T>,public ThreadFuncBase
{
public:
	typedef int (ThreadFuncBase::* TCCALLBACK)(T& data);
	TianchenSendQueue(ThreadFuncBase* obj, TCCALLBACK callback)
		:TianChenQueue<T>(), m_base(obj), m_callback(callback)
	{
		m_thread.Start();
		m_thread.UpdateWorker(::ThreadWorker(this,(FUNCTYPE)&TianchenSendQueue<T>::threadTick));		
	}
	virtual ~TianchenSendQueue() 
	{
		m_base = NULL;
		m_callback == NULL;
		m_thread.Stop();

	}//为什么要设置虚析构:这样才能都调用析构,父类有自己的释放逻辑时,都需要虚析构
protected:
	virtual bool PopFront(T& data) { return false; }
	bool PopFront(){}	
	int threadTick(){}
	
	virtual void DealParam(typename TianChenQueue<T>::PARAM* pParam)
{}
private:
	ThreadFuncBase* m_base;
	TCCALLBACK m_callback;
	TianchenThread m_thread;

};
typedef TianchenSendQueue<std::vector<char>>::TCCALLBACK SENDCALLBACK;
 

线程池
class ThreadFuncBase {};
typedef int (ThreadFuncBase::* FUNCTYPE)();
class ThreadWorker
{
public:
	ThreadWorker() :thiz(NULL), func(NULL) {}
	ThreadWorker(void* obj, FUNCTYPE f) :thiz((ThreadFuncBase*)obj), func(f) {}
	//注意 
	ThreadWorker(const ThreadWorker& worker)
	{
		thiz = worker.thiz;
		func = worker.func;
	}
	ThreadWorker& operator=(const ThreadWorker& worker)
	{
		if (this != &worker)
		{
			thiz = worker.thiz;
			func = worker.func;
		}
		return *this;
	}
	int operator()()
	{//函数调用运算符重载
		if (IsValid()) {
			return (thiz->*func)();
			//理解 thiz是指向类的一个指针 func是指向成员函数的指针  thiz指向func时,需要解引用
		}
		return -1;
	}
	bool IsValid()const
	{
		return (thiz != NULL) && (func != NULL);
	}
private:
	ThreadFuncBase* thiz;//对象指针
	FUNCTYPE func;//成员函数指针
};

class TianchenThread
{
public:
	TianchenThread() {
		m_hThread = NULL;
		m_bStatus = false;
	}
	~TianchenThread() {
		Stop();
	}
	bool Start()
;	
	bool Stop();
	bool IsValid() {//返回true表示有效 返回false表示线程异常或者已经终止
		if (m_hThread == NULL || (m_hThread == INVALID_HANDLE_VALUE))return false;
		return WaitForSingleObject(m_hThread, 0) == WAIT_TIMEOUT; //1,不存在会返回一个错误,2结束了,证明是有效
	}
	void UpdateWorker(const ::ThreadWorker& worker = ::ThreadWorker())
;
	bool IsIdle()
;
private:
	void ThreadWorker(); 
	static void ThreadEntry(void* arg);
private:
	HANDLE m_hThread;
	bool m_bStatus;//false表示线程将关闭,true 表示线程正在运行
	std::atomic<::ThreadWorker*>m_worker; 
};
class TianchenThreadPool
{
public:
	TianchenThreadPool(size_t size);	
	TianchenThreadPool() {}
	~TianchenThreadPool(){}
;	
	bool Invoke() {}
	void Stop(){}
	int DispatchWorker(const ThreadWorker& worker)
;
	bool CheckThreadVaild(size_t index) ;
private:
	std::mutex m_lock;
	std::vector<TianchenThread*>m_threads;
};

服务器接收
class RTSPServer: public ThreadFuncBase
{
public:
	RTSPServer() :m_socket(true), m_status(0),m_pool(10)
	{
		m_threadMain.UpdateWorker(::ThreadWorker(this, (FUNCTYPE)&RTSPServer::threadWorker));
	}
	~RTSPServer();
	int Init(const std::string& strIp = "0.0.0.0", short port = 554);
	int Invoke();
	void Stop();
protected:
	int threadWorker();//接受 返回0继续 返回负数终止 返回其他警告
	RTSPRequest AnalyseRequest(const std::string&data);//解析字符
	RTSPReply MakeReplay(const RTSPRequest& request);//回复
	int ThreadSession();
private:
	ESocket m_socket;
	TAddress m_addr;
	int m_status;//0 未初始化 1 初始化完成 2 正在运行 3 关闭
	TianchenThread m_threadMain;
	TianchenThreadPool m_pool;
	std::map<std::string, RTSPSession>m_mapSessions;//sessions
	static SocketIniter m_initer;//初始化套接字
	TianChenQueue<ESocket>m_clients;
};