Usando o Armazenamento Local do Thread em uma biblioteca de Dynamic-Link

  • Artigo

Esta seção mostra o uso de uma função de ponto de entrada de DLL para configurar um índice TLS (armazenamento local de thread) para fornecer armazenamento privado para cada thread de um processo multithread.

O índice TLS é armazenado em uma variável global, tornando-o disponível para todas as funções de DLL. Este exemplo pressupõe que os dados globais da DLL não sejam compartilhados, pois o índice TLS não é necessariamente o mesmo para cada processo que carrega a DLL.

A função de ponto de entrada usa a função TlsAlloc para alocar um índice TLS sempre que um processo carrega a DLL. Cada thread pode usar esse índice para armazenar um ponteiro para seu próprio bloco de memória.

Quando a função de ponto de entrada é chamada com o valor DLL_PROCESS_ATTACH, o código executa as seguintes ações:

  1. Usa a função TlsAlloc para alocar um índice TLS.
  2. Aloca um bloco de memória a ser usado exclusivamente pelo thread inicial do processo.
  3. Usa o índice TLS em uma chamada para a função TlsSetValue para armazenar o endereço do bloco de memória no slot TLS associado ao índice.

Sempre que o processo cria um novo thread, a função de ponto de entrada é chamada com o valor DLL_THREAD_ATTACH. Em seguida, a função de ponto de entrada aloca um bloco de memória para o novo thread e armazena um ponteiro para ele usando o índice TLS.

Quando uma função requer acesso aos dados associados a um índice TLS, especifique o índice em uma chamada para a função TlsGetValue . Isso recupera o conteúdo do slot TLS para o thread de chamada, que nesse caso é um ponteiro para o bloco de memória dos dados. Quando um processo usa a vinculação de tempo de carga com essa DLL, a função de ponto de entrada é suficiente para gerenciar o armazenamento local do thread. Podem ocorrer problemas com um processo que usa a vinculação em tempo de execução porque a função de ponto de entrada não é chamada para threads que existem antes da função LoadLibrary ser chamada, portanto, a memória TLS não é alocada para esses threads. Este exemplo resolve esse problema verificando o valor retornado pela função TlsGetValue e alocando memória se o valor indicar que o slot TLS para esse thread não está definido.

Quando cada thread não precisa mais usar um índice TLS, ele deve liberar a memória cujo ponteiro está armazenado no slot TLS. Quando todos os threads tiverem terminado de usar um índice TLS, use a função TlsFree para liberar o índice.

Quando um thread termina, a função de ponto de entrada é chamada com o valor DLL_THREAD_DETACH e a memória desse thread é liberada. Quando um processo é encerrado, a função de ponto de entrada é chamada com o valor DLL_PROCESS_DETACH e a memória referenciada pelo ponteiro no índice TLS é liberada.

// The DLL code

#include <windows.h>

static DWORD dwTlsIndex; // address of shared memory
 
// DllMain() is the entry-point function for this DLL. 
 
BOOL WINAPI DllMain(HINSTANCE hinstDLL, // DLL module handle
    DWORD fdwReason,                    // reason called
    LPVOID lpvReserved)                 // reserved
{ 
    LPVOID lpvData; 
    BOOL fIgnore; 
 
    switch (fdwReason) 
    { 
        // The DLL is loading due to process 
        // initialization or a call to LoadLibrary. 
 
        case DLL_PROCESS_ATTACH: 
 
            // Allocate a TLS index.
 
            if ((dwTlsIndex = TlsAlloc()) == TLS_OUT_OF_INDEXES) 
                return FALSE; 
 
            // No break: Initialize the index for first thread.
 
        // The attached process creates a new thread. 
 
        case DLL_THREAD_ATTACH: 
 
            // Initialize the TLS index for this thread.
 
            lpvData = (LPVOID) LocalAlloc(LPTR, 256); 
            if (lpvData != NULL) 
                fIgnore = TlsSetValue(dwTlsIndex, lpvData); 
 
            break; 
 
        // The thread of the attached process terminates.
 
        case DLL_THREAD_DETACH: 
 
            // Release the allocated memory for this thread.
 
            lpvData = TlsGetValue(dwTlsIndex); 
            if (lpvData != NULL) 
                LocalFree((HLOCAL) lpvData); 
 
            break; 
 
        // DLL unload due to process termination or FreeLibrary. 
 
        case DLL_PROCESS_DETACH: 
 
            // Release the allocated memory for this thread.
 
            lpvData = TlsGetValue(dwTlsIndex); 
            if (lpvData != NULL) 
                LocalFree((HLOCAL) lpvData); 
 
            // Release the TLS index.
 
            TlsFree(dwTlsIndex); 
            break; 
 
        default: 
            break; 
    } 
 
    return TRUE; 
    UNREFERENCED_PARAMETER(hinstDLL); 
    UNREFERENCED_PARAMETER(lpvReserved); 
}

// The export mechanism used here is the __declspec(export)
// method supported by Microsoft Visual Studio, but any
// other export method supported by your development
// environment may be substituted.

#ifdef __cplusplus    // If used by C++ code, 
extern "C" {          // we need to export the C interface
#endif

__declspec(dllexport)
BOOL WINAPI StoreData(DWORD dw)
{
   LPVOID lpvData; 
   DWORD * pData;  // The stored memory pointer 

   lpvData = TlsGetValue(dwTlsIndex); 
   if (lpvData == NULL)
   {
      lpvData = (LPVOID) LocalAlloc(LPTR, 256); 
      if (lpvData == NULL) 
         return FALSE;
      if (!TlsSetValue(dwTlsIndex, lpvData))
         return FALSE;
   }

   pData = (DWORD *) lpvData; // Cast to my data type.
   // In this example, it is only a pointer to a DWORD
   // but it can be a structure pointer to contain more complicated data.

   (*pData) = dw;
   return TRUE;
}

__declspec(dllexport)
BOOL WINAPI GetData(DWORD *pdw)
{
   LPVOID lpvData; 
   DWORD * pData;  // The stored memory pointer 

   lpvData = TlsGetValue(dwTlsIndex); 
   if (lpvData == NULL)
      return FALSE;

   pData = (DWORD *) lpvData;
   (*pdw) = (*pData);
   return TRUE;
}
#ifdef __cplusplus
}
#endif

O código a seguir demonstra o uso das funções de DLL definidas no exemplo anterior.

#include <windows.h> 
#include <stdio.h> 
 
#define THREADCOUNT 4 
#define DLL_NAME TEXT("testdll")

VOID ErrorExit(LPSTR); 

extern "C" BOOL WINAPI StoreData(DWORD dw);
extern "C" BOOL WINAPI GetData(DWORD *pdw);
 
DWORD WINAPI ThreadFunc(VOID) 
{   
   int i;

   if(!StoreData(GetCurrentThreadId()))
      ErrorExit("StoreData error");

   for(i=0; i<THREADCOUNT; i++)
   {
      DWORD dwOut;
      if(!GetData(&dwOut))
         ErrorExit("GetData error");
      if( dwOut != GetCurrentThreadId())
         printf("thread %d: data is incorrect (%d)\n", GetCurrentThreadId(), dwOut);
      else printf("thread %d: data is correct\n", GetCurrentThreadId());
      Sleep(0);
   }
   return 0; 
} 
 
int main(VOID) 
{ 
   DWORD IDThread; 
   HANDLE hThread[THREADCOUNT]; 
   int i; 
   HMODULE hm;
 
// Load the DLL

   hm = LoadLibrary(DLL_NAME);
   if(!hm)
   {
      ErrorExit("DLL failed to load");
   }

// Create multiple threads. 
 
   for (i = 0; i < THREADCOUNT; i++) 
   { 
      hThread[i] = CreateThread(NULL, // default security attributes 
         0,                           // use default stack size 
         (LPTHREAD_START_ROUTINE) ThreadFunc, // thread function 
         NULL,                    // no thread function argument 
         0,                       // use default creation flags 
         &IDThread);              // returns thread identifier 
 
   // Check the return value for success. 
      if (hThread[i] == NULL) 
         ErrorExit("CreateThread error\n"); 
   } 
 
   WaitForMultipleObjects(THREADCOUNT, hThread, TRUE, INFINITE); 

   FreeLibrary(hm);
 
   return 0; 
} 
 
VOID ErrorExit (LPSTR lpszMessage) 
{ 
   fprintf(stderr, "%s\n", lpszMessage); 
   ExitProcess(0); 
}

Dados da biblioteca de link dinâmico

Uso de armazenamento local de thread