多线程1

////////////////

    // The following example uses _beginthread and _endthread  
      
    // crt_BEGTHRD.C  
    // compile with: /MT /D "_X86_" /c  
    // processor: x86  
    #include <windows.h>  
    #include <process.h>    /* _beginthread, _endthread */  
    #include <stddef.h>  
    #include <stdlib.h>  
    #include <conio.h>  
      
    void Bounce( void *ch );  
    void CheckKey( void *dummy );  
      
    /* GetRandom returns a random integer between min and max. */  
    #define GetRandom( min, max ) ((rand() % (int)(((max) + 1) - (min))) + (min))  
      
    BOOL repeat = TRUE;     /* Global repeat flag and video variable */  
    HANDLE hStdOut;         /* Handle for console window */  
    CONSOLE_SCREEN_BUFFER_INFO csbi;    /* Console information structure */  
      
    int main()  
    {  
        CHAR    ch = 'A';  
      
        hStdOut = GetStdHandle( STD_OUTPUT_HANDLE );  
      
        /* Get display screen's text row and column information. */  
       GetConsoleScreenBufferInfo( hStdOut, &csbi );  
      
        /* Launch CheckKey thread to check for terminating keystroke. */  
        _beginthread( CheckKey, 0, NULL );  
      
        /* Loop until CheckKey terminates program. */  
        while( repeat )  
        {  
            /* On first loops, launch character threads. */  
            _beginthread( Bounce, 0, (void *) (ch++)  );  
      
            /* Wait one second between loops. */  
            Sleep( 1000L );  
        }  
    }  
      
    /* CheckKey - Thread to wait for a keystroke, then clear repeat flag. */  
    void CheckKey( void *dummy )  
    {  
        _getch();  
        repeat = 0;    /* _endthread implied */  
      
    }  
      
    /* Bounce - Thread to create and and control a colored letter that moves 
     * around on the screen. 
     * 
     * Params: ch - the letter to be moved 
     */  
    void Bounce( void *ch )  
    {  
        /* Generate letter and color attribute from thread argument. */  
        char    blankcell = 0x20;  
        char    blockcell = (char) ch;  
        BOOL    first = TRUE;  
       COORD   oldcoord, newcoord;  
       DWORD   result;  
      
      
        /* Seed random number generator and get initial location. */  
        srand( _threadid );  
        newcoord.X = GetRandom( 0, csbi.dwSize.X - 1 );  
        newcoord.Y = GetRandom( 0, csbi.dwSize.Y - 1 );  
        while( repeat )  
        {  
            /* Pause between loops. */  
            Sleep( 100L );  
      
            /* Blank out our old position on the screen, and draw new letter. */  
            if( first )  
                first = FALSE;  
            else  
             WriteConsoleOutputCharacter( hStdOut, &blankcell, 1, oldcoord, &result );  
             WriteConsoleOutputCharacter( hStdOut, &blockcell, 1, newcoord, &result );  
      
            /* Increment the coordinate for next placement of the block. */  
            oldcoord.X = newcoord.X;  
            oldcoord.Y = newcoord.Y;  
            newcoord.X += GetRandom( -1, 1 );  
            newcoord.Y += GetRandom( -1, 1 );  
      
            /* Correct placement (and beep) if about to go off the screen. */  
            if( newcoord.X < 0 )  
                newcoord.X = 1;  
            else if( newcoord.X == csbi.dwSize.X )  
                newcoord.X = csbi.dwSize.X - 2;  
            else if( newcoord.Y < 0 )  
                newcoord.Y = 1;  
            else if( newcoord.Y == csbi.dwSize.Y )  
                newcoord.Y = csbi.dwSize.Y - 2;  
      
            /* If not at a screen border, continue, otherwise beep. */  
            else  
                continue;  
            Beep( ((char) ch - 'A') * 100, 175 );  
        }  
        /* _endthread given to terminate */  
        _endthread();  
    }  

    /*The following sample code demonstrates how you can use the thread handle returned by _beginthreadex with the synchronization API WaitForSingleObject. The main thread waits for the second thread to terminate before it continues. When the second thread calls _endthreadex, it causes its thread object to go to the signaled state. This allows the primary thread to continue running. This cannot be done with _beginthread and _endthread, because _endthread calls CloseHandle, destroying the thread object before it can be set to the signaled state.*/  
      
      
    // crt_begthrdex.cpp  
    // compile with: /MT  
    #include <windows.h>  
    #include <stdio.h>  
    #include <process.h>  
      
    unsigned Counter;   
    unsigned __stdcall SecondThreadFunc( void* pArguments )  
    {  
        printf( "In second thread...\n" );  
      
        while ( Counter < 1000000 )  
            Counter++;  
      
        _endthreadex( 0 );  
        return 0;  
    }   
      
    int main()  
    {   
        HANDLE hThread;  
        unsigned threadID;  
      
        printf( "Creating second thread...\n" );  
      
        // Create the second thread.  
        hThread = (HANDLE)_beginthreadex( NULL, 0, &SecondThreadFunc, NULL, 0, &threadID );  
      
        // Wait until second thread terminates. If you comment out the line  
        // below, Counter will not be correct because the thread has not  
        // terminated, and Counter most likely has not been incremented to  
        // 1000000 yet.  
        WaitForSingleObject( hThread, INFINITE );  
        printf( "Counter should be 1000000; it is-> %d\n", Counter );  
        // Destroy the thread object.  
        CloseHandle( hThread );  
    }  

    The CreateThread function creates a new thread for a process. The creating thread must specify the starting address of the code that the new thread is to execute. Typically, the starting address is the name of a function defined in the program code (for more information, see ThreadProc). This function takes a single parameter and returns a DWORD value. A process can have multiple threads simultaneously executing the same function.   
      
    /* 
    The following is a simple example that demonstrates how to create a new thread that executes the locally defined function, ThreadProc. The creating thread uses a dynamically allocated buffer to pass unique information to each instance of the thread function. It is the responsibility of the thread function to free the memory. 
     
    The calling thread uses the WaitForMultipleObjects function to persist until all worker threads have terminated. Note that if you were to close the handle to a worker thread before it terminated, this does not terminate the worker thread. However, the handle will be unavailable for use in subsequent function calls.*/  
     
     
    #include <windows.h>  
    #include <strsafe.h>  
     
    #define MAX_THREADS 3  
    #define BUF_SIZE 255  
      
    typedef struct _MyData {  
        int val1;  
        int val2;  
    } MYDATA, *PMYDATA;  
      
    DWORD WINAPI ThreadProc( LPVOID lpParam )   
    {   
        HANDLE hStdout;  
        PMYDATA pData;  
      
        TCHAR msgBuf[BUF_SIZE];  
        size_t cchStringSize;  
        DWORD dwChars;  
      
        hStdout = GetStdHandle(STD_OUTPUT_HANDLE);  
        if( hStdout == INVALID_HANDLE_VALUE )  
            return 1;  
      
        // Cast the parameter to the correct data type.  
      
        pData = (PMYDATA)lpParam;  
      
        // Print the parameter values using thread-safe functions.  
      
        StringCchPrintf(msgBuf, BUF_SIZE, TEXT("Parameters = %d, %d\n"),   
            pData->val1, pData->val2);   
        StringCchLength(msgBuf, BUF_SIZE, &cchStringSize);  
        WriteConsole(hStdout, msgBuf, cchStringSize, &dwChars, NULL);  
      
        // Free the memory allocated by the caller for the thread   
        // data structure.  
      
        HeapFree(GetProcessHeap(), 0, pData);  
      
        return 0;   
    }   
       
    void main()  
    {  
        PMYDATA pData;  
        DWORD dwThreadId[MAX_THREADS];  
        HANDLE hThread[MAX_THREADS];   
        int i;  
      
        // Create MAX_THREADS worker threads.  
      
        for( i=0; i<MAX_THREADS; i++ )  
        {  
            // Allocate memory for thread data.  
      
            pData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,  
                    sizeof(MYDATA));  
      
            if( pData == NULL )  
                ExitProcess(2);  
      
            // Generate unique data for each thread.  
      
            pData->val1 = i;  
            pData->val2 = i+100;  
      
            hThread[i] = CreateThread(   
                NULL,              // default security attributes  
                0,                 // use default stack size    
                ThreadProc,        // thread function   
                pData,             // argument to thread function   
                0,                 // use default creation flags   
                &dwThreadId[i]);   // returns the thread identifier   
       
            // Check the return value for success.   
       
            if (hThread[i] == NULL)   
            {  
                ExitProcess(i);  
            }  
        }  
      
        // Wait until all threads have terminated.  
      
        WaitForMultipleObjects(MAX_THREADS, hThread, TRUE, INFINITE);  
      
        // Close all thread handles upon completion.  
      
        for(i=0; i<MAX_THREADS; i++)  
        {  
            CloseHandle(hThread[i]);  
        }  
    }