std :: thread - называет вашу нить

Question

Новый C++ имеет этот тип std :: thread. Работает как шарм. Теперь я хотел бы дать каждой теме имя для более легкой отладки (например, java). С Pthreads я хотел бы сделать:

pthread_setname_np(pthread_self(), "thread_name"); 

, но как я могу сделать это с помощью C++ 0x? Я знаю, что он использует pthreads под Linux, но я хотел бы сделать свое приложение переносимым. Это вообще возможно?

Answer 1

Портативный способ сделать это - сохранить карту имен, с помощью идентификатора потока, полученную от thread::get_id(). В качестве альтернативы, как указано в комментариях, вы можете использовать переменную thread_local, если вам нужно только получить доступ к имени из потока.

Если вам не нужна переносимость, тогда вы можете получить базовый pthread_t от thread::native_handle() и делать с ними какие-то специфические для платформы шантажи. Имейте в виду, что _np в функциях именования нитей означает «не posix», поэтому они не гарантируются на всех реализациях pthreads.

Answer 2

Вы можете использовать std::thread::native_handle, чтобы получить заданную реализацию, лежащую в основе. Для этого нет стандартной функции.

Вы можете найти пример here.

Answer 3

Для окон [отладчик] вы можете легко использовать «обычный» метод; http://msdn.microsoft.com/en-gb/library/xcb2z8hs.aspx

Просто нужен идентификатор потока, который вы можете получить с помощью

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

Answer 4

попытки сделать обертку для решения многих дистрибутивов Linux, а также Windows. При необходимости отредактируйте.

#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

я и видел это сделано в системе существовавшей с ++ 11 (где мы в основном изобрели свой собственный класс Thread, который был очень похож на StD :: нить) и в одном я писал совсем недавно.

В принципе, пул действительно ставит std :: thread 2 слоя вниз - у вас есть класс PoolThread, который содержит метаданные std :: thread plus, такие как его имя, идентификатор и т. Д. И структуру управления, которая связывает ее с ее управляющий пул и сам ThreadPool. Вы хотите использовать пулы потоков в большинстве потоков кода по нескольким причинам:
1) Вы можете скрыть все явные «отсоединение», «объединение», начало потока на std :: thread construction и т. Д. От пользователей. Это дает МНОГО безопаснее & код чистки.
2) Лучшее управление ресурсами: Слишком много потоков будет искажать производительность даже больше, чем слишком мало. Хорошо построенный пул может выполнять расширенные функции, такие как автоматическая балансировка нагрузки и очистка зависающих или заторможенных потоков.
3) Повторное использование потока: std :: thread сам по себе проще всего использовать, выполняя каждую параллельную задачу в своем потоке. Но создание потоков & разрушение дорогое, и вы можете легко повысить скорость при параллельной обработке, если не будете осторожны. Таким образом, обычно имеет смысл иметь пул потоков, которые вытягивают рабочие задачи из очереди и только выходят после получения некоторого сигнала.
4) Обработка ошибок: std :: thread - это просто контекст выполнения. Если задача, которую вы выполняете на ней, выдает исключение без обработки или std :: thread ITSELF завершается с ошибкой, процесс просто сработает прямо там.Чтобы сделать отказоустойчивую многопоточность, вам нужен пул или что-то подобное, что может быстро поймать такие вещи и, по крайней мере, исправить значимые сообщения об ошибках до того, как процесс погибнет.