following some former advice Multithreaded application, am I doing it right?

I think I have a threadsafe number generator using boost, but my program crashes when I input 1000 iterations. The output .csv file when graphed looks right, but I'm not sure why it's crashing.

It's using _beginthread, and everyone is telling me I should use the more (convoluted) _beingthreadex, which I'm not familiar with. If someone could recommend an example, I would greatly appreciate it.

Also... someone pointed out I should be applying a second parameter to my _beginthread for the array counting start positions, but I have no idea how to pass more than one parameter, other than attempting to use a structure, and I've read structure's and _beginthread don't get along (although, I could just use the boost threads...)

#include <process.h>
#include <windows.h>
#include <iostream>
#include <fstream>
#include <time.h>
#include <random>
#include <boost/random.hpp>

//for srand48_r(time(NULL), &randBuffer); which doesn't work
#include <stdio.h>
#include <stdlib.h>

//#include <thread>

using namespace std;
using namespace boost;
using namespace boost::random;

void myThread0 (void *dummy );
void myThread1 (void *dummy );
void myThread2 (void *dummy );
void myThread3 (void *dummy );

//for random seeds
void initialize();

    //from http://stackoverflow.com/questions/7114043/random-number-generation-in-c11-how-to-generate-how-do-they-work
    uniform_int_distribution<> two(1,2);

    typedef std::mt19937 MyRNG;  // the Mersenne Twister with a popular choice of parameters

    uint32_t seed_val;           // populate somehow

    MyRNG rng1;                   // e.g. keep one global instance (per thread)
    MyRNG rng2;                   // e.g. keep one global instance (per thread)
    MyRNG rng3;                   // e.g. keep one global instance (per thread)
    MyRNG rng4;                   // e.g. keep one global instance (per thread)

//only needed for shared variables
//CRITICAL_SECTION cs1,cs2,cs3,cs4; // global

int main()
{

    ofstream myfile;
    myfile.open ("coinToss.csv");

    int rNum;

    long numRuns;
    long count = 0;
    int divisor = 1;
    float fHolder = 0;
    long counter = 0;
    float percent = 0.0;

    //?
    //unsigned threadID;

    //HANDLE hThread;

    initialize();

    HANDLE hThread[4];

    const int size = 100000;

    int array[size];

    printf ("Runs (uses multiple of 100,000) ");
    cin >> numRuns;

    for (int a = 0; a < numRuns; a++)
     {

            hThread[0] = (HANDLE)_beginthread( myThread0, 0, (void*)(array) );
            hThread[1] = (HANDLE)_beginthread( myThread1, 0, (void*)(array) );
            hThread[2] = (HANDLE)_beginthread( myThread2, 0, (void*)(array) );
            hThread[3] = (HANDLE)_beginthread( myThread3, 0, (void*)(array) );

            //waits for threads to finish before continuing
            WaitForMultipleObjects(4, hThread, TRUE, INFINITE);

            //closes handles I guess?
            CloseHandle( hThread[0] );
            CloseHandle( hThread[1] );
            CloseHandle( hThread[2] );
            CloseHandle( hThread[3] );

        //dump array into calculations
        //average array into fHolder

            //this could be split into threads as well
            for (int p = 0; p < size; p++)
             {
                counter += array[p] == 2 ? 1 : -1;
                //cout << array[p] << endl;
                //cout << counter << endl;
            }

            //this fHolder calculation didn't work
            //fHolder = counter / size;

            //so I had to use this
            cout << counter << endl;
            fHolder = counter;
            fHolder = fHolder / size;

            myfile << fHolder << endl;

    }
}

    void initialize()
    {

      //seed value needs to be supplied
      //rng1.seed(seed_val*1);

      rng1.seed((unsigned int)time(NULL));
      rng2.seed(((unsigned int)time(NULL))*2);
      rng3.seed(((unsigned int)time(NULL))*3);
      rng4.seed(((unsigned int)time(NULL))*4);
    };


void myThread0 (void *param)
{
    //EnterCriticalSection(&cs1); //aquire the critical section object

    int *i = (int *)param;

    for (int x = 0; x < 25000; x++)
    {
        //doesn't work, part of merssene twister
        //i[x] = next();
        i[x] = two(rng1);

        //original srand
        //i[x] = rand() % 2 + 1;

        //doesn't work for some reason.
        //uint_dist2(rng);

        //i[x] = qrand() % 2 + 1;
        //cout << i[x] << endl;
    }
    //LeaveCriticalSection(&cs1); // release the critical section object

}

void myThread1 (void *param)
{
    //EnterCriticalSection(&cs2); //aquire the critical section object

    int *i = (int *)param;

    for (int x = 25000; x < 50000; x++)
    {
        //param[x] = rand() % 2 + 1;
        i[x] = two(rng2);
        //i[x] = rand() % 2 + 1;
        //cout << i[x] << endl;
    }
    //LeaveCriticalSection(&cs2); // release the critical section object

}

void myThread2 (void *param)
{
    //EnterCriticalSection(&cs3); //aquire the critical section object

    int *i = (int *)param;

    for (int x = 50000; x < 75000; x++)
    {
        i[x] = two(rng3);
        //i[x] = rand() % 2 + 1;
        //cout << i[x] << endl;
    }
    //LeaveCriticalSection(&cs3); // release the critical section object

}

void myThread3 (void *param)
{
    //EnterCriticalSection(&cs4); //aquire the critical section object

    int *i = (int *)param;

    for (int x = 75000; x < 100000; x++)
    {
        i[x] = two(rng4);
        //i[x] = rand() % 2 + 1;
        //cout << i[x] << endl;
    }
    //LeaveCriticalSection(&cs4); // release the critical section object

}