Multithreading in C++ Class Module

bool MC_Simulation::threads_calling_function(	const char* bond_data_file, 
const char* portfolio_data_file,int no_portfolio){

        // MAX_THREADS is global variable 
	HANDLE			aThread[MAX_THREADS]; 
	DWORD			dwThreadID[MAX_THREADS];
	PTHREAD_DATA		pthread_arg[MAX_THREADS];
	int			scenario_range[MAX_THREADS+1];

	// evaluating beginning and end scenarios for each thread
        // No_Scenarios is Class Information
	scenario_range[0]=0;
	for(int i=1;i<=MAX_THREADS;i++){
                  scenario_range[i] = scenario_range[i-1] +
                  No_Scenarios/MAX_THREADS + (No_Scenarios%MAX_THREADS < i); 
		}
		scenario_range[MAX_THREADS] = No_Scenarios;

		// Create a mutex with no initial owner
		ghMutex = CreateMutex( 
			NULL,              // default security attributes
			FALSE,             // initially not owned
			NULL);             // unnamed mutex
                // check error...
		if (ghMutex == NULL).... 
		

		// create worker threads
		for (int index=0; index<max_threads;index++){>
                   // allocate memory
                   pthread_arg[index] = (PTHREAD_DATA) HeapAlloc(GetProcessHeap(), 
                                        HEAP_ZERO_MEMORY,
                			sizeof(THREAD_DATA));

                   // set the information for each thread 
			
		pthread_arg[index]->first_scenario  = scenario_range[index];
		pthread_arg[index]->last_scenario   = scenario_range[index+1];
		pthread_arg[index]->no_portfolio    = no_portfolio;
		pthread_arg[index]->mc_simulation_p  = this;

		// each thread is supposed to write data to its own file 
		sprintf(pthread_arg[index]->bond_data_file,
                       "%s_%d",bond_data_file,index);
		sprintf(pthread_arg[index]->portfolio_data_file,
                       "%s_%d",portfolio_data_file,index);

// Create the thread handles
aThread[index] = CreateThread(NULL, 0, thread_function , pthread_arg[index], 0, &dwThreadID[index]);
                       // check error
			if(aThread[index] ==NULL).....
		}    // end for loop

	// Wait until all threads have terminated.
       	WaitForMultipleObjects(MAX_THREADS, aThread, TRUE, INFINITE);

	   // close threads and mutex handles
	   for(int i=0; i<max_threads;>		CloseHandle(aThread[i]);
		if(pthread_arg[i] != NULL){
		    HeapFree(GetProcessHeap(), 0, pthread_arg[i]);
		     pthread_arg[i] = NULL;    // Ensure address is not reused.
	        }
	    }

	   CloseHandle(ghMutex);

	   return true;
}

DWORD WINAPI MC_Simulation::thread_function(LPVOID arg){


   DWORD	dwWaitResult; 
   int		current_thread_id = GetCurrentThreadId();
   bool		success = true;

   PTHREAD_DATA			pDataArray;
   pDataArray =			(PTHREAD_DATA) arg;
   char				bond_data_file[_MAX_FNAME];
   char				portfolio_data_file[_MAX_FNAME];

   const int			no_portfolio	= pDataArray->no_portfolio;
   const long			first_scenario	= pDataArray->first_scenario;
   const long			last_scenario	= pDataArray->last_scenario;

   // each thread is calculating independently and is not changing
   strcpy(bond_data_file,pDataArray->bond_data_file);
   strcpy(portfolio_data_file,pDataArray->portfolio_data_file);
    
 
   const MC_Simulation*	mc_simulation_p = pDataArray->mc_simulation_p;


    // Request ownership of mutex.
 	dwWaitResult = WaitForSingleObject( 
			   ghMutex,    // handle to mutex
			   INFINITE);  // no time-out interval

	switch (dwWaitResult) 
       	 {
		// The thread got ownership of the mutex
            	case WAIT_OBJECT_0: 
               	 __try { 
                    
                    // TODO: Do the monte carlo Calculations
                    //  mc_simulation_p is the pointer to MyClass
		      success = :: bond_portfolio_valuation(no_portfolio,
                                   bond_data_file, 
                                    portfolio_data_file, 
                                    first_scenario, 
                                   last_scenario, 
                                   mc_simulation_p);
                    // check which thread is operating:
      		 printf("Now working with Thread %d...\n", 
                         GetCurrentThreadId());

                }  // end try

                 __finally { 
                // Release ownership of the mutex object
                 if (!ReleaseMutex(ghMutex)) 
                    { 
                     // Handle error.
                      ::ErrorHandler(TEXT("Mutex can not be released"));
                     } 
               	 }  // end finally
             	 break; 

                 // The thread got ownership of an abandoned mutex
            	 // The database is in an indeterminate state
           	 case WAIT_ABANDONED: 
                	return FALSE; 

	} // end switch statement

return success;
}	// mythread function