1. Clase de hilo abstracto
Primero defina una clase de subproceso abstracta:
esta clase de subproceso implementa las funciones de iniciar un subproceso, detener un subproceso, salir de un subproceso y verificar si el subproceso sale:
y establecer la entrada del subproceso como una función virtual pura, y dejar que la clase de subproceso específica implementarlo por sí mismo
#include <thread>
class XThread
{
public:
//启动线程
virtual void Start();
//设置线程退出标志 并等待
virtual void Stop();
//等待线程退出（阻塞）
virtual void Wait();
//线程是否退出
bool is_exit();
private:
//线程入口
virtual void Main() = 0;
bool is_exit_ = false;
std::thread th_;
};
Implementación de la clase de subprocesos:
start (): al llamar a start () del objeto de clase Xthread, primero establezca el indicador de salida en falso y luego use la función de entrada de subprocesos y este puntero como parámetros para llamar a la diferencia entre la función miembro del constructor del hilo y la
función ordinaria El primer parámetro de puntero implícito de la función miembro es el puntero this, a través del cual se accede a los miembros del objeto de clase.
No es suficiente que el constructor de un subproceso use solo el puntero de función en la clase, también necesita el puntero this del objeto
wait (): si el subproceso actual se puede unir (no se puede separar), espere a que el subproceso exit
Specific: el estado del subproceso -- --unible y separado
stop(): establezca la posición del indicador de salida en verdadero, y la entrada del subproceso de la clase de subproceso específica juzgará si continuar el bucle a través del bit del indicador en el tiempo bucle, y luego llamar a esperar para esperar a que el hilo actual salga
#include "xthread.h"
using namespace std;
//启动线程
void XThread::Start()
{
is_exit_ = false;
th_ = thread(&XThread::Main, this);
}
//设置线程退出标志 并等待
void XThread::Stop()
{
is_exit_ = true;
Wait();
}
//等待线程退出（阻塞）
void XThread::Wait()
{
if (th_.joinable())
th_.join();
}
//线程是否退出
bool XThread::is_exit()
{
return is_exit_;
}
En segundo lugar, la clase de hilo específico
Heredado de la clase de subproceso abstracto y define una función de envío, otros subprocesos llaman a esta función para pasar mensajes a la clase de subproceso específica (comunicación de subprocesos) La función principal
utiliza la palabra clave override, lo que indica que la función se reescribe, para evitar la escritura errores
class XMsgServer:public XThread
{
public:
//给当前线程发消息
void SendMsg(std::string msg);
private:
//处理消息的线程入口函数
void Main() override;
//消息队列缓冲
std::list<std::string> msgs_;
//互斥访问消息队列
std::mutex mux_;
};
La función de la función de entrada de este subproceso es leer el mensaje enviado por el subproceso principal desde la cola de mensajes y mostrarlo. Los
puntos a tener en cuenta son los siguientes:
01 Se debe agregar la suspensión al ciclo infinito, de lo contrario, la función de entrada puede ocupan la CPU todo el tiempo, (entre dos bucles while El intervalo es muy corto. Durante este intervalo, es posible que la CPU no pueda programar la ejecución de otros subprocesos. El rendimiento aquí es seguir ejecutando la cola de mensajes de recepción y el envío la cola de mensajes no ha podido obtener el bloqueo. La cola de mensajes está vacía y todavía se está recibiendo. Esto es, por supuesto, No) 02
Use unique_lock para administrar recursos mutuamente excluyentes, no es necesario desbloquearlos específicamente
#include "xmsg_server.h"
#include <iostream>
using namespace std;
using namespace this_thread;
//处理消息的线程入口函数
void XMsgServer::Main()
{
while (!is_exit())
{
sleep_for(10ms);
unique_lock<mutex> lock(mux_);
if (msgs_.empty())
continue;
while (!msgs_.empty())
{
//消息处理业务逻辑
cout << "recv : " << msgs_.front() << endl;
msgs_.pop_front();
}
}
}
//给当前线程发消息
void XMsgServer::SendMsg(std::string msg)
{
unique_lock<mutex> lock(mux_);
msgs_.push_back(msg);
}
Tres, la función principal
#include "xmsg_server.h"
#include <sstream>
using namespace std;
int main(int argc, char* argv[])
{
XMsgServer server;
server.Start();
for (int i = 0; i < 10; i++)
{
stringstream ss;
ss << " msg : " << i + 1;
server.SendMsg(ss.str());
this_thread::sleep_for(500ms);
}
server.Stop();
return 0;
}
La función principal genera 10 mensajes y los envía a los subprocesos que procesan los mensajes.El
efecto es el siguiente:
