Многопоточность

#include <windows.h>
#include <process.h>
#include <stdio.h>
 
CRITICAL_SECTION cs;
int a[ 5 ];
 
void Thread( void* pParams )
{
    int i, num = 0;
 
    while ( TRUE )
    {
        EnterCriticalSection( &cs );
        for ( i = 0; i < 5; i++ ) a[ i ] = num;
        LeaveCriticalSection( &cs );
        num++;
    }
}
 
int main( void )
 
{ 
    InitializeCriticalSection( &cs );
    _beginthread( Thread, 0, NULL );
 
    while( TRUE )
    {
        EnterCriticalSection( &cs );
        printf( "%d %d %d %d %d\n", 
            a[ 0 ], a[ 1 ], a[ 2 ],
            a[ 3 ], a[ 4 ] );
        LeaveCriticalSection( &cs );
    }
    return 0;
}

// New3DRenderer03_05_13.cpp : Defines the entry point for the application.
 
#include "stdafx.h"
#include "SpinningObjects.h"
#include "ModelClass.h"
#include "MatrixClass.h"
 
#define MAX_LOADSTRING 100
 
// Global Variables:
HINSTANCE hInst;                                // current instance
TCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name
 
// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
 
int APIENTRY _tWinMain(HINSTANCE hInstance,
                       HINSTANCE hPrevInstance,
                       LPTSTR    lpCmdLine,
                       int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
 
    // TODO: Place code here.
    MSG msg;
    HACCEL hAccelTable;
 
    // Initialize global strings
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_SPINNINGOBJECTS, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
    // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }
 
    hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_SPINNINGOBJECTS));
 
    // Main message loop:
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
 
    return (int) msg.wParam;
}
 
//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    This function and its usage are only necessary if you want this code
//    to be compatible with Win32 systems prior to the 'RegisterClassEx'
//    function that was added to Windows 95. It is important to call this function
//    so that the application will get 'well formed' small icons associated
//    with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;
 
    wcex.cbSize = sizeof(WNDCLASSEX);
 
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_SPINNINGOBJECTS));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_SPINNINGOBJECTS);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
    return RegisterClassEx(&wcex);
}
 
//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    HWND hWnd;
 
    hInst = hInstance; // Store instance handle in our global variable
 
    hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
 
    if (!hWnd)
    {
        return FALSE;
    }
 
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
 
    return TRUE;
}
 
//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
int vCount, fCount, nCount;
VertexClass *vArray; 
FaceClass *vfArray;
FaceClass *nfArray;
VertexClass tempVertex[10000];
const int IDT_TIMER1 = 1;
float angle = 0.0f;
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    PAINTSTRUCT ps;
    HDC hdc, bdc;
    HBITMAP backBuffer;
    RECT client;
    GetClientRect(hWnd, &client);
 
    switch (message)
    {
    case WM_COMMAND:
        wmId    = LOWORD(wParam);
        wmEvent = HIWORD(wParam);
        // Parse the menu selections:
        switch (wmId)
        {
        case IDM_ABOUT:
            DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
            break;
        case IDM_EXIT:
            DestroyWindow(hWnd);
            break;
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
        break;
    case WM_CREATE: 
        vCount = 0;
        fCount = 0;
        nCount = 0;
 
        ModelClass::GetModelData(&vCount, &fCount, &nCount);
 
        vArray = new VertexClass[vCount];
        vfArray = new FaceClass[fCount];
        nfArray = new FaceClass[fCount];
 
        ModelClass::LoadModel(vArray, vfArray, nfArray);
 
        for (int i = 0; i < fCount; i++)
        {
            tempVertex[i] = vArray[i];
            MatrixClass::BuildTransformationMatrix(&tempVertex[i].x, &tempVertex[i].y, &tempVertex[i].z, &angle);
        }
 
        SetTimer(hWnd, IDT_TIMER1, 40, 0);
        break;
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
        hdc = GetDC(hWnd);
        bdc = CreateCompatibleDC(hdc);
        backBuffer = CreateCompatibleBitmap(hdc, client.right - client.left, client.bottom - client.top);
        SelectObject(bdc, backBuffer);
        SetDCBrushColor(bdc, RGB(0, 0, 0));
        Rectangle(bdc, client.left, client.top, client.right, client.bottom);
 
        // TODO: Add any drawing code here...
        for (int i = 0; i < fCount; i++)
        {
            tempVertex[i] = vArray[i];
            MatrixClass::BuildTransformationMatrix(&tempVertex[i].x, &tempVertex[i].y, &tempVertex[i].z, &angle);
 
            MoveToEx(bdc, tempVertex[vfArray[i].a - 1].x, tempVertex[vfArray[i].a - 1].y, false);
            LineTo(bdc, tempVertex[vfArray[i].b - 1].x, tempVertex[vfArray[i].b - 1].y);
 
            MoveToEx(bdc, tempVertex[vfArray[i].b - 1].x, tempVertex[vfArray[i].b - 1].y, false);
            LineTo(bdc, tempVertex[vfArray[i].c - 1].x, tempVertex[vfArray[i].c - 1].y);
 
            MoveToEx(bdc, tempVertex[vfArray[i].a - 1].x, tempVertex[vfArray[i].a - 1].y, false);
            LineTo(bdc, tempVertex[vfArray[i].c - 1].x, tempVertex[vfArray[i].c - 1].y);
        }
 
        BitBlt(hdc, client.left, client.top, client.right, client.bottom, bdc, 0, 0, SRCCOPY);
        DeleteObject(backBuffer);
        DeleteDC(bdc);
        ReleaseDC(hWnd, hdc);
        EndPaint(hWnd, &ps);
        break;
    case WM_TIMER: 
        switch (wParam) 
    case IDT_TIMER1: 
        angle += 1.0f;
        if (angle > 360.0f) 
            angle = 0.0f;
        InvalidateRect(hWnd, 0, false);
        break;
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}
 
// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;
 
    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}