You shouldn't constantly be starting threads, nor creating large numbers of threads.

You can have just two threads, the main game thread and the background-loading thread.

The main thread sends messages to the background thread, saying it wants to load a model, and the background thread sends messages back once it's loaded. To achieve thread-safety, you just need to make sure that any variables that are used by both threads cannot be used by both threads at the same time (which is what mutexes do for you).

Here's a simple example of two threads communicating via message queues:struct LoadRequest
{
std::string fileName;
Model* target;
};

struct LoadResult
{
Model* target;
void* data;
};

CRITICAL_SECTION loadRequestMutex;
CRITICAL_SECTION loadResultMutex;
std::deque<LoadRequest> loadRequestQueue;//you must lock/unlock loadRequestMutex whenever you use this variable
std::deque<LoadResult> loadResultQueue;//you must lock/unlock loadResultMutex whenever you use this variable

void MainThread_LoadFile(const std::string& fileName, Model* target)
{
LoadRequest message;
message.fileName = fileName;
message.target = target;

// Send a request to the background thread:
EnterCriticalSection(&loadRequestMutex);
loadRequestQueue.push_back(message);
LeaveCriticalSection(&loadRequestMutex);
}

DWORD WINAPI BackgroundThread_Loop( LPVOID lpParam )
{
while(!g_Quit)
{
Sleep(0);
LoadRequest inMessage;
bool receivedMessage = false;

//Get a request from the main thread:
EnterCriticalSection(&loadRequestMutex);
if( !loadRequestQueue.empty() )
{
inMessage = loadRequestQueue.front();
loadRequestQueue.pop_front();
receivedMessage = true;
}
LeaveCriticalSection(&loadRequestMutex);

//if there was a request sent:
if( receivedMessage )
{
//read the file:
FILE* fp = fopen( inMessage.fileName, "rb" );
fseek( fp, 0, SEEK_END );
long size = ftell( fp );
rewind( fp );
char* buffer = new char[Size];
fread( buffer, 1, Size, fp );
fclose( fp );

LoadResult outMessage;
outMessage.target = inMessage.target;
outMessage.data = buffer;

//Send the results back to the main thread:
EnterCriticalSection(&loadResultMutex);
loadResultQueue.push_back(message);
LeaveCriticalSection(&loadResultMutex);
}
}
}

void MainThread_Loop()
{
//Create the mutexes
InitializeCriticalSection(&loadRequestMutex);
InitializeCriticalSection(&loadResultMutex);
//Start the background loop
HANDLE backgroundThread = CreateThread( 0, 0, BackgroundThread_Loop, 0, 0, 0);

while(!g_Quit)
{
//Run the game:

Update(); // might call MainThread_LoadFile

Render();

// Process results from the background thread:
EnterCriticalSection(&loadResultMutex);
while( !loadResultQueue.empty() )
{
LoadResult message = loadResultQueue.front();
loadResultQueue.pop_front();

message.target->DataLoaded( message.data );//give the loaded data to the model object

delete [] message.data;
}
LeaveCriticalSection(&loadResultMutex);
}

//Make sure the background thread is finsihed
WaitForSingleObject(backgroundThread, INFINITE);
//Clean up the mutexes
DeleteCriticalSection(&loadRequestMutex);
DeleteCriticalSection(&loadResultMutex);
}