mfc两个线程的创建、启动、安全结束实例

**实例设计思路：**启动/停止线程1的按钮、启动/停止线程2的按钮、启动/停止所有线程的按钮。两个线程可以独立运行，执行不同的任务，并且可以分别控制或同时控制，具有良好的扩展性和可维护性。

**独立的线程控制变量：**每个线程有自己的句柄、事件对象和状态标志

线程1：m_hThread1, m_hStopEvent1, m_bStopThread1, m_bThread1Active

线程2：m_hThread2, m_hStopEvent2, m_bStopThread2, m_bThread2Active

线程标识：在THREAD_PARAM结构中添加了nThreadID字段，用于标识是哪个线程

**统一的线程函数：**使用一个静态线程函数ThreadProc，通过线程ID参数区分不同线程

SimpleThreadDemoDlg.h

// SimpleThreadDemoDlg.h : header file
//

#if !defined(AFX_SIMPLETHREADDEMODLG_H__ACD22E2E_074B_4E66_8D22_531CE01316D0__INCLUDED_)
#define AFX_SIMPLETHREADDEMODLG_H__ACD22E2E_074B_4E66_8D22_531CE01316D0__INCLUDED_

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

/////////////////////////////////////////////////////////////////////////////
// CSimpleThreadDemoDlg dialog

class CSimpleThreadDemoDlg : public CDialog
{
// Construction
public:
	CSimpleThreadDemoDlg(CWnd* pParent = NULL);	// standard constructor
     virtual ~CSimpleThreadDemoDlg();  // 析构函数
    HANDLE m_hThread1;
    HANDLE m_hStopEvent1;
    BOOL m_bStopThread1;
    BOOL m_bThread1Active;
    
    // 线程2控制
    HANDLE m_hThread2;
    HANDLE m_hStopEvent2;
    BOOL m_bStopThread2;
    BOOL m_bThread2Active;
    
    // 线程参数结构
    struct THREAD_PARAM {
        CSimpleThreadDemoDlg* pDlg;
        int nThreadID;      // 1:线程1, 2:线程2
        int nCounter;
    };
	private:
    // 安全终止方法
    void SafeTerminateThread1();
    void SafeTerminateThread2();
    void SafeTerminateAllThreads();  // 新增：同时终止两个线程

	  // 静态线程函数
    static UINT ThreadProc(LPVOID pParam);
    
    // 线程工作函数
    void DoThreadWork(int nThreadID, int nIteration);
// Dialog Data
	//{{AFX_DATA(CSimpleThreadDemoDlg)
	enum { IDD = IDD_SIMPLETHREADDEMO_DIALOG };
		// NOTE: the ClassWizard will add data members here
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CSimpleThreadDemoDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	HICON m_hIcon;

	// Generated message map functions
	//{{AFX_MSG(CSimpleThreadDemoDlg)
	virtual BOOL OnInitDialog();
	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	afx_msg void OnButtonStart1();
	afx_msg void OnButtonStop1();
	afx_msg void OnButtonStart2();
	afx_msg void OnButtonStop2();
	afx_msg void OnButtonStartAll();
	afx_msg void OnButtonStopAll();
	afx_msg void OnDestroy();
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_SIMPLETHREADDEMODLG_H__ACD22E2E_074B_4E66_8D22_531CE01316D0__INCLUDED_)

SimpleThreadDemoDlg.cpp

// SimpleThreadDemoDlg.cpp : implementation file
//

#include "stdafx.h"
#include "SimpleThreadDemo.h"
#include "SimpleThreadDemoDlg.h"

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

/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialog Data
	//{{AFX_DATA(CAboutDlg)
	enum { IDD = IDD_ABOUTBOX };
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CAboutDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	//{{AFX_MSG(CAboutDlg)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
	//{{AFX_DATA_INIT(CAboutDlg)
	//}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAboutDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
	//{{AFX_MSG_MAP(CAboutDlg)
		// No message handlers
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSimpleThreadDemoDlg dialog

CSimpleThreadDemoDlg::CSimpleThreadDemoDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CSimpleThreadDemoDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CSimpleThreadDemoDlg)
	// 初始化线程1状态
    m_bStopThread1 = FALSE;
    m_bThread1Active = FALSE;
    m_hThread1 = NULL;
    m_hStopEvent1 = NULL;
    
    // 初始化线程2状态
    m_bStopThread2 = FALSE;
    m_bThread2Active = FALSE;
    m_hThread2 = NULL;
    m_hStopEvent2 = NULL;
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CSimpleThreadDemoDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CSimpleThreadDemoDlg)
		// NOTE: the ClassWizard will add DDX and DDV calls here
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CSimpleThreadDemoDlg, CDialog)
	//{{AFX_MSG_MAP(CSimpleThreadDemoDlg)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON_START1, OnButtonStart1)
	ON_BN_CLICKED(IDC_BUTTON_STOP1, OnButtonStop1)
	ON_BN_CLICKED(IDC_BUTTON_START2, OnButtonStart2)
	ON_BN_CLICKED(IDC_BUTTON_STOP2, OnButtonStop2)
	ON_BN_CLICKED(IDC_BUTTON_START_ALL, OnButtonStartAll)
	ON_BN_CLICKED(IDC_BUTTON_STOP_ALL, OnButtonStopAll)
    ON_WM_DESTROY()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSimpleThreadDemoDlg message handlers

BOOL CSimpleThreadDemoDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Add "About..." menu item to system menu.

	// IDM_ABOUTBOX must be in the system command range.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		CString strAboutMenu;
		strAboutMenu.LoadString(IDS_ABOUTBOX);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	
	// TODO: Add extra initialization here
	 // 创建事件对象
    m_hStopEvent1 = CreateEvent(NULL, TRUE, FALSE, NULL);
    m_hStopEvent2 = CreateEvent(NULL, TRUE, FALSE, NULL);
	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CSimpleThreadDemoDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CSimpleThreadDemoDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CSimpleThreadDemoDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}



// 线程函数
UINT CSimpleThreadDemoDlg::ThreadProc(LPVOID pParam)
{
    THREAD_PARAM* pThreadParam = (THREAD_PARAM*)pParam;
    CSimpleThreadDemoDlg* pDlg = pThreadParam->pDlg;
    int nThreadID = pThreadParam->nThreadID;
    
    TRACE("线程%d开始运行\n", nThreadID);
    
    // 执行5次循环
    for(int i = 1; i <= 5; i++)
    {
        // 根据线程ID检查停止标志
        BOOL bStopFlag = FALSE;
        HANDLE hStopEvent = NULL;
        
        if(nThreadID == 1)
        {
            bStopFlag = pDlg->m_bStopThread1;
            hStopEvent = pDlg->m_hStopEvent1;
        }
        else if(nThreadID == 2)
        {
            bStopFlag = pDlg->m_bStopThread2;
            hStopEvent = pDlg->m_hStopEvent2;
        }
        
        // 检查停止标志
        if(bStopFlag)
        {
            TRACE("线程%d接收到停止信号\n", nThreadID);
            break;
        }
        
        // 检查事件对象（可选）
        if(hStopEvent && WaitForSingleObject(hStopEvent, 0) == WAIT_OBJECT_0)
        {
            TRACE("线程%d接收到事件停止信号\n", nThreadID);
            break;
        }
        
        // 执行工作
        pDlg->DoThreadWork(nThreadID, i);
        
        // 休眠1秒
        Sleep(1000);
    }
    
    // 线程结束，更新状态
    if(nThreadID == 1)
    {
        pDlg->m_bThread1Active = FALSE;
    }
    else if(nThreadID == 2)
    {
        pDlg->m_bThread2Active = FALSE;
    }
    
    // 清理参数
    delete pThreadParam;
    
    TRACE("线程%d运行结束\n", nThreadID);
    return 0;
}

void CSimpleThreadDemoDlg::DoThreadWork(int nThreadID, int nIteration)
{
    TRACE("线程%d执行第%d项工作\n", nThreadID, nIteration);
    // 这里可以添加实际的工作代码，根据线程ID执行不同的任务
}

/////////////////////////////////////////////////////////////////////////////
// 启动线程1
void CSimpleThreadDemoDlg::OnButtonStart1()
{
    TRACE("=== 启动线程1 ===\n");
    
    if(m_bThread1Active)
    {
        AfxMessageBox("线程1已经在运行");
        return;
    }
    
    // 重置事件
    if(m_hStopEvent1)
    {
        ResetEvent(m_hStopEvent1);
    }
    
    // 初始化标志
    m_bStopThread1 = FALSE;
    m_bThread1Active = TRUE;
    
    // 创建线程参数
    THREAD_PARAM* pParam = new THREAD_PARAM;
    pParam->pDlg = this;
    pParam->nThreadID = 1;
    pParam->nCounter = 0;
    
    // 创建线程（使用CREATE_SUSPENDED，确保完全初始化后再运行）
    CWinThread* pThread = AfxBeginThread(
        ThreadProc,
        pParam,
        THREAD_PRIORITY_NORMAL,
        0,
        CREATE_SUSPENDED
    );
    
    if(pThread == NULL)
    {
        AfxMessageBox("创建线程1失败");
        m_bThread1Active = FALSE;
        delete pParam;
        return;
    }
    
    // 保存句柄
    m_hThread1 = pThread->m_hThread;
    
    // 恢复线程运行
    pThread->ResumeThread();
    
    TRACE("线程1启动成功，ID: %d\n", pThread->m_nThreadID);
    AfxMessageBox("线程1已启动");
}

/////////////////////////////////////////////////////////////////////////////
// 停止线程1
void CSimpleThreadDemoDlg::OnButtonStop1()
{
    TRACE("=== 停止线程1 ===\n");
    
    if(!m_bThread1Active)
    {
        AfxMessageBox("没有正在运行的线程1");
        return;
    }
    
    // 安全终止线程
    SafeTerminateThread1();
    
    AfxMessageBox("线程1已停止");
}

/////////////////////////////////////////////////////////////////////////////
// 启动线程2
void CSimpleThreadDemoDlg::OnButtonStart2()
{
    TRACE("=== 启动线程2 ===\n");
    
    if(m_bThread2Active)
    {
        AfxMessageBox("线程2已经在运行");
        return;
    }
    
    // 重置事件
    if(m_hStopEvent2)
    {
        ResetEvent(m_hStopEvent2);
    }
    
    // 初始化标志
    m_bStopThread2 = FALSE;
    m_bThread2Active = TRUE;
    
    // 创建线程参数
    THREAD_PARAM* pParam = new THREAD_PARAM;
    pParam->pDlg = this;
    pParam->nThreadID = 2;
    pParam->nCounter = 0;
    
    // 创建线程（使用CREATE_SUSPENDED，确保完全初始化后再运行）
    CWinThread* pThread = AfxBeginThread(
        ThreadProc,
        pParam,
        THREAD_PRIORITY_NORMAL,
        0,
        CREATE_SUSPENDED
    );
    
    if(pThread == NULL)
    {
        AfxMessageBox("创建线程2失败");
        m_bThread2Active = FALSE;
        delete pParam;
        return;
    }
    
    // 保存句柄
    m_hThread2 = pThread->m_hThread;
    
    // 恢复线程运行
    pThread->ResumeThread();
    
    TRACE("线程2启动成功，ID: %d\n", pThread->m_nThreadID);
    AfxMessageBox("线程2已启动");
}

/////////////////////////////////////////////////////////////////////////////
// 停止线程2
void CSimpleThreadDemoDlg::OnButtonStop2()
{
    TRACE("=== 停止线程2 ===\n");
    
    if(!m_bThread2Active)
    {
        AfxMessageBox("没有正在运行的线程2");
        return;
    }
    
    // 安全终止线程
    SafeTerminateThread2();
    
    AfxMessageBox("线程2已停止");
}

/////////////////////////////////////////////////////////////////////////////
// 启动所有线程
void CSimpleThreadDemoDlg::OnButtonStartAll()
{
    TRACE("=== 启动所有线程 ===\n");
    
    // 启动线程1（如果未运行）
    if(!m_bThread1Active)
    {
        OnButtonStart1();
    }
    
    // 启动线程2（如果未运行）
    if(!m_bThread2Active)
    {
        OnButtonStart2();
    }
    
    AfxMessageBox("所有线程已启动");
}

/////////////////////////////////////////////////////////////////////////////
// 停止所有线程
void CSimpleThreadDemoDlg::OnButtonStopAll()
{
    TRACE("=== 停止所有线程 ===\n");
    
    SafeTerminateAllThreads();
    
    AfxMessageBox("所有线程已停止");
}

/////////////////////////////////////////////////////////////////////////////
// 安全终止线程1
void CSimpleThreadDemoDlg::SafeTerminateThread1()
{
    TRACE("安全终止线程1\n");
    
    if(!m_bThread1Active)
    {
        TRACE("线程1未激活\n");
        return;
    }
    
    // 1. 设置停止标志和事件
    m_bStopThread1 = TRUE;
    if(m_hStopEvent1)
    {
        SetEvent(m_hStopEvent1);
    }
    
    // 2. 等待线程正常结束
    if(m_hThread1)
    {
        TRACE("等待线程1正常退出...\n");
        
        // 等待3秒让线程正常退出
        DWORD dwWaitResult = WaitForSingleObject(m_hThread1, 3000);
        
        if(dwWaitResult == WAIT_OBJECT_0)
        {
            TRACE("线程1正常退出\n");
        }
        else if(dwWaitResult == WAIT_TIMEOUT)
        {
            TRACE("线程1超时未退出，尝试强制终止\n");
            
            // 3. 强制终止（最后手段）
            // 警告：这可能导致资源泄漏，只在必要时使用
            if(!TerminateThread(m_hThread1, 0))
            {
                TRACE("强制终止线程1失败，错误代码: %d\n", GetLastError());
            }
            else
            {
                // 等待线程完全终止
                WaitForSingleObject(m_hThread1, 1000);
                TRACE("线程1已被强制终止\n");
            }
        }
        
        // 4. 关闭句柄
        CloseHandle(m_hThread1);
        m_hThread1 = NULL;
    }
    
    // 5. 重置状态
    m_bThread1Active = FALSE;
    m_bStopThread1 = FALSE;
    
    TRACE("安全终止线程1完成\n");
}

/////////////////////////////////////////////////////////////////////////////
// 安全终止线程2
void CSimpleThreadDemoDlg::SafeTerminateThread2()
{
    TRACE("安全终止线程2\n");
    
    if(!m_bThread2Active)
    {
        TRACE("线程2未激活\n");
        return;
    }
    
    // 1. 设置停止标志和事件
    m_bStopThread2 = TRUE;
    if(m_hStopEvent2)
    {
        SetEvent(m_hStopEvent2);
    }
    
    // 2. 等待线程正常结束
    if(m_hThread2)
    {
        TRACE("等待线程2正常退出...\n");
        
        // 等待3秒让线程正常退出
        DWORD dwWaitResult = WaitForSingleObject(m_hThread2, 3000);
        
        if(dwWaitResult == WAIT_OBJECT_0)
        {
            TRACE("线程2正常退出\n");
        }
        else if(dwWaitResult == WAIT_TIMEOUT)
        {
            TRACE("线程2超时未退出，尝试强制终止\n");
            
            // 3. 强制终止（最后手段）
            // 警告：这可能导致资源泄漏，只在必要时使用
            if(!TerminateThread(m_hThread2, 0))
            {
                TRACE("强制终止线程2失败，错误代码: %d\n", GetLastError());
            }
            else
            {
                // 等待线程完全终止
                WaitForSingleObject(m_hThread2, 1000);
                TRACE("线程2已被强制终止\n");
            }
        }
        
        // 4. 关闭句柄
        CloseHandle(m_hThread2);
        m_hThread2 = NULL;
    }
    
    // 5. 重置状态
    m_bThread2Active = FALSE;
    m_bStopThread2 = FALSE;
    
    TRACE("安全终止线程2完成\n");
}

/////////////////////////////////////////////////////////////////////////////
// 安全终止所有线程
void CSimpleThreadDemoDlg::SafeTerminateAllThreads()
{
    TRACE("安全终止所有线程\n");
    
    // 终止线程1
    if(m_bThread1Active)
    {
        SafeTerminateThread1();
    }
    
    // 终止线程2
    if(m_bThread2Active)
    {
        SafeTerminateThread2();
    }
    
    TRACE("所有线程终止完成\n");
}

/////////////////////////////////////////////////////////////////////////////
// 窗口销毁处理
void CSimpleThreadDemoDlg::OnDestroy() 
{
    TRACE("=== 窗口销毁处理开始 ===\n");
    
    // 确保所有线程结束
    SafeTerminateAllThreads();
    
    CDialog::OnDestroy();
    
    TRACE("=== 窗口销毁处理结束 ===\n");
}

/////////////////////////////////////////////////////////////////////////////
// 析构函数
CSimpleThreadDemoDlg::~CSimpleThreadDemoDlg()
{
    // 确保所有线程结束
    SafeTerminateAllThreads();
    
    // 关闭事件句柄
    if (m_hStopEvent1)
    {
        CloseHandle(m_hStopEvent1);
        m_hStopEvent1 = NULL;
    }
    
    if (m_hStopEvent2)
    {
        CloseHandle(m_hStopEvent2);
        m_hStopEvent2 = NULL;
    }
}

运行程序