多线程演示程序（ＭＦＣ）

// ThreadDemo1View.h : interface of the CThreadDemo1View class
//
/////////////////////////////////////////////////////////////////////////////

#if !defined(AFX_THREADDEMO1VIEW_H__3CAF4D6E_8775_11D1_B719_00C0A83735D8__INCLUDED_)
#define AFX_THREADDEMO1VIEW_H__3CAF4D6E_8775_11D1_B719_00C0A83735D8__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

typedef struct
{
HWND hWnd;
BOOL *lpKillThread;
} THREAD_INFO;

class CThreadDemo1View : public CView
{
protected: // create from serialization only
CThreadDemo1View();
DECLARE_DYNCREATE(CThreadDemo1View)

// Attributes
public:
CThreadDemo1Doc* GetDocument();

BOOL m_bKillThread;
CWinThread *m_pThread;
THREAD_INFO m_ThreadInfo;

// Operations
public:

// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CThreadDemo1View)
public:
virtual void OnDraw(CDC* pDC); // overridden to draw this view
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
//}}AFX_VIRTUAL

// Implementation
public:
virtual ~CThreadDemo1View();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif

protected:

// Generated message map functions
protected:
//{{AFX_MSG(CThreadDemo1View)
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};

#ifndef _DEBUG // debug version in ThreadDemo1View.cpp
inline CThreadDemo1Doc* CThreadDemo1View::GetDocument()
{ return (CThreadDemo1Doc*)m_pDocument; }
#endif

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

//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_THREADDEMO1VIEW_H__3CAF4D6E_8775_11D1_B719_00C0A83735D8__INCLUDED_)

// ThreadDemo1View.cpp : implementation of the CThreadDemo1View class
//

#include "stdafx.h"
#include "ThreadDemo1.h"

#include "ThreadDemo1Doc.h"
#include "ThreadDemo1View.h"

#include <math.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CThreadDemo1View

IMPLEMENT_DYNCREATE(CThreadDemo1View, CView)

BEGIN_MESSAGE_MAP(CThreadDemo1View, CView)
//{{AFX_MSG_MAP(CThreadDemo1View)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

UINT ThreadProc( LPVOID lpParam )
{
// Get a THREAD_INFO pointer from the
// parameter that was passed in.
THREAD_INFO *lpThreadInfo =
(THREAD_INFO *) lpParam;

// The next six variables represent
// values used to draw the spirograph;
unsigned char Red, Green, Blue;
int nFixedRadius = 80;
int nMovingRadius = 10;
int nMovingOffset = 70;

// Begin colors based on the system time. This
// makes the color somewhat random.
Red = (unsigned char)
( GetTickCount() & 0x000000ff );
Green = (unsigned char)
( ( GetTickCount() & 0x00000ff0 ) >> 4 );
Blue = (unsigned char)
( ( GetTickCount() & 0x0000ff00 ) >> 8 );

while( *lpThreadInfo->lpKillThread == FALSE ){

// Get a DC for the window.
HDC hdc = ::GetDC( lpThreadInfo->hWnd );

// Get the client rect so we can
// calculate the center point.
RECT Rect;
::GetClientRect( lpThreadInfo->hWnd, &Rect );
int nMidx = Rect.right / 2;
int nMidy = Rect.bottom / 2;

// Clear the window.
::InvalidateRect( lpThreadInfo->hWnd, NULL, TRUE );
::UpdateWindow( lpThreadInfo->hWnd );

// Create a pen based on the color. Select it
// into the DC and remember the old pen so
// we can select it back in later.
HPEN hPen, hOldPen;
hPen =
::CreatePen( PS_SOLID, 1, RGB( Red, Green, Blue ) );
hOldPen = (HPEN) ::SelectObject( hdc, hPen );

// Iterate through a bunch of times and
// draw the spirograph.
int prevx, prevy, x = 0, y = 0;
for( int i=0; i<=500; i++ ){

// Remember x and y.
prevx = x;
prevy = y;

// Calculate the new x and y.
x = (int) ( ( nFixedRadius + nMovingRadius ) *
cos( (double) i ) -
( nMovingRadius + nMovingOffset ) *
cos((double)(( ( nFixedRadius + nMovingRadius ) /
nMovingRadius ) * i ) ) );
y = (int) ( ( nFixedRadius + nMovingRadius ) *
sin( (double) i ) -
( nMovingRadius + nMovingOffset ) *
sin((double)(( ( nFixedRadius + nMovingRadius ) /
nMovingRadius ) * i ) ) );

// Draw the line (or move to the first
// point if this is the first time through).
if( i > 0 )
::LineTo( hdc, x + nMidx, y + nMidy );
else
::MoveToEx( hdc, x + nMidx, y + nMidy, NULL );

}

// Increment the color variables so
// that the colors move around.
Red += 6;
Green += 5;
Blue += 4;

// Increase the fixed radius and
// limit it to a max of 150.
nFixedRadius++;
if( nFixedRadius > 170 )
nFixedRadius = 90;
// Increase the moving radius and
// limit it to a max of 120.
nMovingRadius++;
if( nMovingRadius > 40 )
nMovingRadius = 10;

// Increase the moving offset and
// limit it to a max of 90.
nMovingOffset++;
if( nMovingOffset > 100 )
nMovingOffset = 70;

// Select the old pen into the DC,
// delete the pen we created, and
// release the DC we got.
::SelectObject( hdc, hOldPen );
::DeleteObject( hPen );
::ReleaseDC( lpThreadInfo->hWnd, hdc );

// Sleep so we don't chew up too
// much CPU time.
Sleep( 200 );
}

return( 0 );

}

/////////////////////////////////////////////////////////////////////////////
// CThreadDemo1View construction/destruction

CThreadDemo1View::CThreadDemo1View()
{

// This is the flag that tells the
// thread to quit.
m_bKillThread = FALSE;

// NULL the pointer to the thread so
// we know it hasn't been created.
m_pThread = NULL;

}

CThreadDemo1View::~CThreadDemo1View()
{
// Get the thread handle into local space since
// the thread will delete itself.
HANDLE hThread = m_pThread->m_hThread;

// Set the flag to kill the thread to TRUE;
m_bKillThread = TRUE;

// Wait for the thread to end.
::WaitForSingleObject( hThread, 5000 );

}

BOOL CThreadDemo1View::PreCreateWindow(CREATESTRUCT& cs)
{
return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CThreadDemo1View drawing

void CThreadDemo1View::OnDraw(CDC* pDC)
{
CThreadDemo1Doc* pDoc = GetDocument();
ASSERT_VALID(pDoc);

// If the m_pThread is NULL, we need to kick
// off the thread.
if( m_pThread == NULL )
{
// Store the window handle and the Kill flag.
m_ThreadInfo.hWnd = m_hWnd;
m_ThreadInfo.lpKillThread = &m_bKillThread;

// Start the thread.
m_pThread = AfxBeginThread(ThreadProc, (LPVOID) &m_ThreadInfo);
}

}

/////////////////////////////////////////////////////////////////////////////
// CThreadDemo1View diagnostics

#ifdef _DEBUG
void CThreadDemo1View::AssertValid() const
{
CView::AssertValid();
}

void CThreadDemo1View::Dump(CDumpContext& dc) const
{
CView::Dump(dc);
}

CThreadDemo1Doc* CThreadDemo1View::GetDocument() // non-debug version is inline
{
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CThreadDemo1Doc)));
return (CThreadDemo1Doc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CThreadDemo1View message handlers