c++ - tiempo - leyenda del hilo rojo paulo coelho

std:: thread-nombrando tu hilo

Question

El nuevo C ++ tiene este std :: tipo de subproceso. Funciona de maravilla. Ahora me gustaría darle a cada hilo un nombre para una depuración más fácil (como java lo permite). Con pthreads, yo haría:

pthread_setname_np(pthread_self(), "thread_name");

pero ¿cómo puedo hacer esto con c ++ 0x? Sé que utiliza pthreads debajo en los sistemas Linux, pero me gustaría que mi aplicación sea portátil. ¿Es posible?

Answer 1

Ambos he visto esto hecho en un sistema anterior a c ++ 11 (donde básicamente inventamos nuestra propia clase de subprocesos que era muy similar a std :: thread) y en uno que escribí bastante recientemente.

Básicamente, el conjunto realmente pone std :: thread 2 capas hacia abajo: tiene una clase PoolThread que contiene un std :: thread más metadatos como su nombre, ID, etc. y la estructura de control que lo vincula a su grupo de control, y el ThreadPool en sí mismo. Desea utilizar grupos de subprocesos en el código más subprocesado por varias razones:
1) Puede ocultar todo el explícito "detach", "join", start thread en std :: thread construction, etc. de los usuarios. Eso produce MUCHO código más seguro y limpio.
2) Mejor administración de recursos: Demasiados hilos paralizarán el rendimiento incluso más que tener muy pocos. Una agrupación bien construida puede hacer cosas avanzadas como el equilibrio de carga automático y la limpieza de hilos colgados o en punto muerto.
3) Reutilización de subprocesos: std :: thread es más fácil de usar ejecutando cada tarea paralela en su propio subproceso. Pero la creación y la destrucción de subprocesos son costosas y pueden inundar fácilmente el aumento de velocidad del procesamiento paralelo si no tienes cuidado. Por lo tanto, normalmente tiene más sentido tener subprocesos de grupo que extraigan tareas de una cola y solo salgan después de recibir alguna señal.
4) Manejo de errores: std :: thread es solo un contexto de ejecución. Si la tarea que está ejecutando arroja una excepción no controlada o std :: thread ITSELF falla, el proceso simplemente se bloqueará allí mismo. Para hacer un multihilo tolerante a fallas, necesita un Pool o algo similar que pueda detectar rápidamente tales cosas y al menos emitir mensajes de error significativos antes de que el proceso falle.

Answer 2

Para Windows [depurador], puede usar fácilmente el método "normal"; http://msdn.microsoft.com/en-gb/library/xcb2z8hs.aspx

Solo necesita el ID del hilo que puede obtener a través de

#include <windows.h>
DWORD ThreadId = ::GetThreadId( static_cast<HANDLE>( mThread.native_handle() ) );

Answer 3

Puede usar std::thread::native_handle para obtener la subcapa de implementación definida thread. No hay una función estándar para eso de forma nativa.

Puedes encontrar un ejemplo here .

Answer 4

Un intento de hacer un contenedor para tratar con muchos Linuxes y Windows. Por favor edita según sea necesario.

#ifdef _WIN32
#include <windows.h>
const DWORD MS_VC_EXCEPTION=0x406D1388;

#pragma pack(push,8)
typedef struct tagTHREADNAME_INFO
{
   DWORD dwType; // Must be 0x1000.
   LPCSTR szName; // Pointer to name (in user addr space).
   DWORD dwThreadID; // Thread ID (-1=caller thread).
   DWORD dwFlags; // Reserved for future use, must be zero.
} THREADNAME_INFO;
#pragma pack(pop)


void SetThreadName(uint32_t dwThreadID, const char* threadName)
{

  // DWORD dwThreadID = ::GetThreadId( static_cast<HANDLE>( t.native_handle() ) );

   THREADNAME_INFO info;
   info.dwType = 0x1000;
   info.szName = threadName;
   info.dwThreadID = dwThreadID;
   info.dwFlags = 0;

   __try
   {
      RaiseException( MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info );
   }
   __except(EXCEPTION_EXECUTE_HANDLER)
   {
   }
}
void SetThreadName( const char* threadName)
{
    SetThreadName(GetCurrentThreadId(),threadName);
}

void SetThreadName( std::thread* thread, const char* threadName)
{
    DWORD threadId = ::GetThreadId( static_cast<HANDLE>( thread->native_handle() ) );
    SetThreadName(threadId,threadName);
}

#else
void SetThreadName(std::thread* thread, const char* threadName)
{
   auto handle = thread->native_handle();
   pthread_setname_np(handle,threadName);
}


#include <sys/prctl.h>
void SetThreadName( const char* threadName)
{
  prctl(PR_SET_NAME,threadName,0,0,0);
}

#endif

Answer 5

Una forma portátil de hacerlo es mantener un mapa de nombres, codificado por el ID del thread::get_id() , obtenido de thread::get_id() . Alternativamente, como se sugiere en los comentarios, puede usar una variable thread_local , si solo necesita acceder al nombre desde el hilo.

Si no necesita portabilidad, entonces puede obtener el pthread_t subyacente de thread::native_handle() y hacer los chanchullos específicos de la plataforma que desee con eso. Tenga en cuenta que _np en las funciones de nomenclatura de hilos significa "no posicionado", por lo que no está garantizado que esté disponible en todas las implementaciones de pthreads.