问无法在C++中使用线程创建文件

EN

void *write(void *name)
{
    FILE * fd;
    char fname[100];
    snprintf(fname, sizeof(fname), "output%d", *(int*)name);
    ...


int main(int argc, char * argv[])
{
    ....
    pthread_t ths[numOfThreads];
    int fileNum[numOfThreads];
    int i;
    for (i = 0; i < numOfThreads; i++)
    {
        fileNum[i] = i;
        if (pthread_create(&ths[i], NULL, write, (void *)&fileNum[i])) 
        {
            fprintf(stderr, "ERROR: FAILD TO CREATE THREAD %d", i);
            exit(1);
        }
    }
    ....

// Compiled on Eclipse/Microsoft C Compiler
// compile with: /MT /D "_X86_" /c
// processor: x86
#include <Windows.h>
#include <process.h>    /* _beginthread, _endthread */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

struct ThreadParameterBlock
{
    int  threadNr;     //
    char fname[13];    // outputxx.bin\0
    int  numBlocks;    // expected number of blocks for this file
    int  blockSize;    // Number of bytes per block
    int  num_writes;   // actual number of writes
    char fill_char;    // for each byte
    clock_t  time_done;
    int  thread_done;  // 1 is running, 0 is stopped

};

void A_Writing_Thread(struct ThreadParameterBlock *TPB)
{
     // each thread has its own stack
     FILE *fd;

     int i;

     char *block;

     block = (char *) malloc(TPB->blockSize);
     if (block != NULL)
     {
       memset(block, TPB->fill_char, TPB->blockSize);

       fd = fopen(TPB->fname, "w");

       if (NULL == fd)
       {
          fprintf(stderr, "ERROR: FAILED TO OPEN FILE %s\n", TPB->fname);
       } else {

           for (i = 0; i < TPB->numBlocks; i++)
           {
              // to help demo parallelism of threads,
              // some threads run slow
              if (i%10 == 0)
              {
                  if (TPB->threadNr == 1)     {Sleep(50L);}
                  if ((TPB->threadNr%2) == 0) {Sleep(100L);}
                  if ((TPB->threadNr%3) == 0) {Sleep(200L);}
                  // glad I'm NOT thread 6!
              }
              fwrite(block, sizeof(TPB->blockSize), 1, fd);
              TPB->num_writes++;
           }

       }

       if (fd != NULL) {fclose(fd);}

       free(block);
     }

     printf("\nThread %d done.", TPB->threadNr);

     TPB->time_done   = clock();
     // only exit is thru this code...
     // thread done
     TPB->thread_done = 1;

     _endthread();
}

main()
{

    int numOfThreads = 0;
    int sizeOfDisk = 0;

    int nr_blocks;

    int thread_done_count;

    int blockSize = 4096;

    char ch = 'A';

    int i;

    // allow up to 10 threads
    struct ThreadParameterBlock *thread_array[10];
    struct ThreadParameterBlock *TPB;

    printf("Enter: Size of Disk(MB) white_space  number_of_threads press enter :");
    fflush(stdout);

    scanf("%d %d", &sizeOfDisk, &numOfThreads);

    if (sizeOfDisk < 0)  {sizeOfDisk = 1;}
    if (sizeOfDisk > 10) {sizeOfDisk = 10;}

    if (numOfThreads < 0)  {numOfThreads = 1;}
    if (numOfThreads > 10) {numOfThreads = 10;}

    nr_blocks = (sizeOfDisk * 1024 * 1024) / (numOfThreads * blockSize);
    printf("\ncreating %d threads to allocate %d blocks of 4096 bytes, per thread/file.\n",
                  numOfThreads, nr_blocks);
    fflush(stdout);

    for (i = 0; i < numOfThreads; i++)
    {
        thread_array[i] = TPB = (struct ThreadParameterBlock *)
                                    malloc(sizeof(struct ThreadParameterBlock));

        TPB->threadNr    = i + 1;
        TPB->time_done   = 0;
        TPB->thread_done = 0;
        TPB->numBlocks   = nr_blocks;
        TPB->blockSize   = blockSize;
        TPB->num_writes  = 0;
        TPB->fill_char   = ch++;
        sprintf(TPB->fname, "output%02d.bin", i+1);

        printf("\nstarting thread %d", i+1);
        fflush(stdout);

        /* On first loops, launch character threads. */
        _beginthread(A_Writing_Thread, 0, thread_array[i]);

    }

    // essentially a join...
    while (1)
    {
       /* Wait one second between polls of threads */
       Sleep( 250L );

       thread_done_count = 0;
       for (i = 0; i < numOfThreads; i++)
       {
           thread_done_count += thread_array[i]->thread_done;
       }

       if (thread_done_count >= numOfThreads) {break;}

    }

    printf("\nAll threads are done.");

    printf("\n\nThread Summary");
    for (i = 0; i < numOfThreads; i++)
    {
        printf("\nThread %2d completed %4d writes(%dkB) at %5d to <%s>.",         thread_array[i]->threadNr,
                thread_array[i]->num_writes,
                (thread_array[i]->num_writes*thread_array[i]->blockSize) / 1024,
                thread_array[i]->time_done,
                thread_array[i]->fname);

        // free parameter block for thread i
        free(thread_array[i]);
    }

} // end main;