Windows系统平台经历了从16位到32位的转变后，系统运行方式和任务管理方式有了很大的变化，在Windows 95和Windows NT中，每个Win32程序在独立的进程空间上运行，32位地址空间使我们从16位段式结构的64K段限制中摆脱出来，逻辑上达到了4G的线性地址空间。这样，我们在设计程序时就不再需要考虑编译的段模式，同时还提高了大程序的运行效率。独立进程空间的另一个更大的优越性是大大提高了系统的稳定性，一个应用程序的异常错误不会影响其它的应用程序，这对于现在的桌面环境尤为重要。

　　在Windows的一个进程内，包含一个或多个线程。线程是指进程的一条执行路径，它包含独立的堆栈和CPU寄存器状态，每个线程共享所有的进程资源，包括打开的文件、信号标识及动态分配的内存等等。一个进程内的所有线程使用同一个32位地址空间，而这些线程的执行由系统调度程序控制，调度程序决定哪个线程可执行以及什么时候执行线程。线程有优先级别，优先权较低的线程必须等到优先权较高的线程执行完任务后再执行。在多处理器的机器上，调度程序可将多个线程放到不同的处理器上去运行，这样就可使处理器的任务平衡，也提高了系统的运行效率。

　　32位Windows环境下的Win32 API提供了多线程应用程序开发所需要的接口函数，但Win16和Win32对多线程应用并不支持，利用Visual C++ 5.0中提供的标准C库也可以开发多线程应用程序，而相应的MFC4.21类库则封装了多线程编程的类，因而用户在开发时可根据应用程序的需要和特点选择相应的工具。

　　如果用户的应用程序需要有多个任务同时进行相应的处理，则使用多线程是较理想的选择。例如，就网络文件服务功能的应用程序而言，若采用单线程编程方法，则需要循环检查网络的连接、磁盘驱动器的状况，并在适当的时候显示这些数据，必须等到一遍查询后才能刷新数据的显示。对使用者来说，延迟可能很长。而在应用多线程的情况下可将这些任务分给多个线程，一个线程负责检查网络，另一个线程管理磁盘驱动器，还有一个线程负责显示数据，三个线程结合起来共同完成文件服务，使用者也可以及时看到网络的变化。多线程应用范围很广，尤其是在目前的桌面平台上，系统的许多功能如网络(Internet)、打印、字处理、图形图像、动画和文件管理都在一个系统下运行，更需要我们的应用程序能够同时处理多个事件，而这些正是多线程可以实现的。本文讲述了利用Visual C++ 5.0进行多线程开发的编程技术。

　　二、基于Visual C++的多线程编程

　　Visual C++ 5.0提供了Windows应用程序的集成开发环境Developer Studio。在这个环境里，用户既可以编写C风格的32位Win32应用程序，也可以利用MFC类库编写C++风格的应用程序，二者各有其优点：基于Win32的应用程序执行代码小巧，运行效率高，但要求程序员编写的代码较多，且需要管理所有系统提供给程序的资源；而基于MFC类库的应用程序可以快速建立起应用程序，类库为程序员提供了大量的封装类，而且Developer Studio为程序员提供了一些工具来管理用户源程序，其缺点是类库代码很庞大，应用程序的执行代码离不开这些代码。由于使用类库所带来的快速、简捷和功能强大等优越性，因此，除非有特殊的需要，否则Visual C++提倡使用MFC类库进行应用程序开发。

　　多线程的编程在Win32方式下和MFC类库支持下的原理是一致的，进程的主线程在任何需要的时候都可以创建新的线程。当线程执行完任务后，自动中止线程；当进程结束后，所有的线程都中止。所有活动的线程共享进程的资源。因此，在编程时需要考虑在多个线程访问同一资源时产生冲突的问题：当一个线程正在访问一个进程对象时，另一个线程要改变该对象，这时可能会产生错误的结果。所以，程序员编程时要解决这种冲突。

　　下面给大家介绍一下在Win32 基础上进行多线程编程的过程。

　　1.用Win32函数创建和中止线程

　　Win32函数库中提供了多线程控制的操作函数，包括创建线程、中止线程、建立互斥区等。首先，在应用程序的主线程或者其它活动线程的适当地方创建新的线程。创建线程的函数如下：

　　HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId );

　　其中，参数lpThreadAttributes 指定了线程的安全属性，在Windows 95中被忽略；dwStackSize 指定了线程的堆栈深度；lpStartAddress 指定了线程的起始地址，一般情况为下面的原型函数：DWORD WINAPI ThreadFunc( LPVOID );lpParameter指定了线程执行时传送给线程的32位参数，即上面函数的参数；dwCreationFlags指定了线程创建的特性； lpThreadId 指向一个DWORD变量，可返回线程ID值。

　　如果创建成功则返回线程的句柄，否则返回NULL。

　　创建了新的线程后，则该线程就开始启动执行了。如果在dwCreationFlags中用了CREATE_SUSPENDED特性，那么线程并不马上执行，而是先挂起，等到调用ResumeThread后才开始启动线程，在这个过程中可以调用函数：

　　BOOL SetThreadPriority( HANDLE hThread, int nPriority);

　　来设置线程的优先权。

　　当线程的函数返回后，线程自动中止。如果在线程的执行过程中中止的话，则可调用函数：

　　VOID ExitThread( DWORD dwExitCode);

　　如果在线程的外面中止线程的话，则可调用下面的函数：

　　BOOL TerminateThread( HANDLE hThread, DWORD dwExitCode );

　　但应注意：该函数可能会引起系统不稳定，而且线程所占用的资源也不释放。因此，一般情况下，建议不要使用该函数。

　　如果要中止的线程是进程内的最后一个线程，则在线程被中止后相应的进程也应中止。

　　2.用Win32函数控制线程对共享资源的访问

　　在线程体内，如果该线程完全独立，与其它的线程没有数据存取等资源操作上的冲突，则可按照通常单线程的方法进行编程。但是，在多线程处理时情况常常不是这样，线程之间经常要同时访问一些资源。例如，一个线程负责公式计算，另一个线程负责结果的显示，两个线程都要访问同一个结果变量。这时如果不进行冲突控制的话，则很可能显示的是不正确的结果。

　　对共享资源进行访问引起冲突是不可避免的，但我们可用以下办法来进行操作控制：

　　(1) 通过设置线程的互斥体对象，在可能冲突的地方进行同步控制。

　　首先，建立互斥体对象，得到句柄：

　　HANDLE CreateMutex( );

　　然后，在线程可能冲突区域的开始（即访问共享资源之前），调用WaitForSingleObject将句柄传给函数，请求占用互斥体对象：

　　dwWaitResult = WaitForSingleObject(hMutex, 5000L);

　　共享资源访问完后，释放对互斥体对象的占用：

　　ReleaseMutex(hMutex);

　　互斥体对象在同一时刻只能被一个线程占用。当互斥体对象被一个线程占用时，若有另一线程想占用它，则必须等到前一线程释放后才能成功。

　　(2) 设置信号：在操作共享资源前，打开信号；完成操作后，关闭信号。这类似于互斥体对象的处理。

　　首先，创建信号对象：

　　HANDLE CreateSemaphore( );

　　或者打开一个信号对象：

　　HANDLE OpenSemaphore( );

　　然后，在线程的访问共享资源之前调用WaitForSingleObject。

　　共享资源访问完后，释放对信号对象的占用：

　　ReleaseSemaphore();

　　信号对象允许同时对多个线程共享资源的访问，在创建对象时指定最大可同时访问的线程数。当一个线程申请访问成功后，信号对象中的计数器减一；调用ReleaseSemaphore函数后，信号对象中的计数器加一。其中，计数器值大于等于0，小于等于创建时指定的最大值。利用信号对象，我们不仅可以控制共享资源的访问，还可以在应用的初始化时候使用。假定一个应用在创建一个信号对象时，将其计数器的初始值设为0，这样就阻塞了其它线程，保护了资源。待初始化完成后，调用ReleaseSemaphore函数将其计数器增加至最大值，进行正常的存取访问。

　　(3) 利用事件对象的状态，进行线程对共享资源的访问。

　　用ResetEvent函数设置事件对象状态为不允许线程通过；用SetEvent函数设置事件对象状态为可以允许线程通过。

　　事件分为手工释放和自动释放。如果是手工释放，则按照上述两函数处理事件的状态；如果是自动释放，则在一个线程结束后，自动清除事件状态，允许其它线程通过。

　　(4) 设置排斥区。在排斥区中异步执行时，它只能在同一进程的线程之间共享资源处理。虽然此时上面介绍的三种方法均可使用，但是，使用排斥区的方法则使同步管理的效率更高；

　　先定义一个CRITICAL_SECTION结构的排斥区对象，在进程使用之前先对对象进行初始化，调用如下函数：

　　VOID InitializeCriticalSection( LPCRITICAL_SECTION );

　　当一个线程使用排斥区时，调用函数：

　　EnterCriticalSection或者TryEnterCriticalSection

　　当要求占用、退出排斥区时，调用函数：

　　LeaveCriticalSection

　　释放对排斥区对象的占用，供其它线程使用。

　　互斥体对象、信号对象和事件对象也可以用于进程间的线程同步操作。在用Win32函数创建了对象时，我们可以指定对象的名字，还可以设置同步对象在子进程的继承性。创建返回的是HANDLE句柄，我们可以用函数DuplicateHandle来复制对象句柄，这样每个进程都可以拥有同一对象的句柄，实现进程之间的线程同步操作。另外，在同一进程内，我们可以用OpenMutex、OpenSemaphore和OpenEvent来获得指定名字的同步对象的句柄。

　　排斥区异步执行的线程同步方法只能用于同一进程的线程之间共享资源处理，但是这种方法的使用效率较高，而且编程也相对简单一些。

　　在Visual C++中，除了利用Win32函数进行多线程同步控制外，如果我们用到了MFC类库，则可利用已经封装成C++类结构的同步对象，使我们的编程更加简捷。

　　三、基于MFC的多线程编程

　　在Visual C++ 5.0附带的MFC 4.21类库中，也提供了多线程编程的支持，基本原理与上面所讲的基于Win32函数的设计一致，但由于MFC对同步对象作了封装，因此对用户编程实现来说更加方便，避免了对象句柄管理上的繁琐工作。更重要的是，在多个窗口线程情况下，MFC中直接提供了用户接口线程的设计。

　　在MFC中，线程分为两种：用户接口线程和辅助线程。用户接口线程常用于接收用户的输入，处理相应的事件和消息。在用户接口线程中，包含一个消息处理循环，其中CWinApp就是一个典型的例子，它从CWinThread派生出来，负责处理用户输入产生的事件和消息。辅助线程常用于任务处理（比如计算）不要求用户输入，对用户而言，它在后台运行。Win32 API并不区分这两种线程的类型，它只是获取线程的起始地址，然后开始执行线程。而MFC则针对不同的用户需要作了分类。如果我们需要编写多个有用户接口的线程的应用程序，则利用Win32 API要写很多的框架代码来完成每个线程的消息事件的处理，而用MFC则可以充分发挥MFC中类的强大功能，还可以使用ClassWizard来帮助管理类的消息映射和成员变量等，我们就可以把精力集中到应用程序的相关代码编写上。

　　辅助线程编程较为简单，设计的思路与上节所讲的基本一致：一个基本函数代表了一个线程，创建并启动线程后，则线程进入运行状态；如果线程用到共享资源，则需要进行资源同步处理。共享资源的同步处理在两种线程模式下完全一致。

　　我们知道：基于MFC的应用程序有一个应用对象，它是CWinApp派生类的对象，该对象代表了应用进程的主线程。当线程执行完(通常是接收到WM_QUIT消息)并退出线程时，由于进程中没有其它线程的存在，故进程也自动结束。类CWinApp从CWinThread派生出来，CWinThread是用户接口线程的基本类。我们在编写用户接口线程时，需要从CWinThread派生我们自己的线程类，ClassWizard可以帮助我们完成这个工作。

　　下面列出编写用户接口线程的基本步骤。

　　1.用ClassWizard派生一个新的类，设置基类为CWinThread

　　注意：类的DECLARE_DYNCREATE 和 IMPLEMENT_DYNCREATE宏是必需的，因为创建线程时需要动态创建类的对象。根据需要可将初始化和结束代码分别放到类的InitInstance和ExitInstance函数中。如果需要创建窗口，则可在InitInstance函数中完成。

　　2.创建线程并启动线程

　　可以用两种方法来创建用户接口线程。

　　（1）MFC提供了两个版本的AfxBeginThread函数，其中一个用于创建用户接口线程，函数原型如下：

　　 CWinThread* AfxBeginThread(CRuntimeClass* pThreadClass, int nPriority, UINT nStackSize , DWORD dwCreateFlags, LPSECURITY_ATTRIBUTES lpSecurityAttrs );

　　其中，参数pThreadClass指定线程的运行类，函数返回线程对象。

　　在创建线程时，可以指定线程先挂起，将参数dwCreateFlags设置为CREATE_SUSPENDED。然后，做一些初试工作，如对变量赋值等。最后，再调用线程类的ResumeThread函数启动线程。

　　函数AfxBeginThread的另一个版本指定一个线程函数并设置相应的参数，其它设置及用法与上述函数基本相同。

　　（2）我们也可以不用AfxBeginThread创建线程，而是分两步完成：首先，调用线程类的构造函数创建一个线程对象；其次，调用CWinThread::CreateThread函数来创建该线程。

　　注意：在这种情况下，在线程类中需要有公有的构造函数以创建其相应的C++对象。

　　线程建立并启动后，则线程在线程函数执行过程中一直有效。如果是线程对象，则在对象被删除之前，先结束线程。CWinThread已经为我们完成了线程结束的工作。

　　3. 同步对象的使用

　　不管是辅助线程还是用户接口线程，在存取共享资源时，都需要保护共享资源，以免引起冲突，造成错误。处理方法类似于Win32 API函数的使用，但MFC为我们提供了几个同步对象C++类，即CSyncObject、CMutex、CSemaphore、CEvent、CCriticalSection。这里，CSyncObject为其它四个类的基类，后四个类分别对应前面所讲的四个Win32 API同步对象。

　　通常，我们在C++对象的成员函数中使用共享资源，或者把共享资源封装在C++类的内部。我们可将线程同步操作封装在对象类的实现函数当中，这样在应用中的线程使用C++对象时，就可以像一般对象一样使用它，简化了使用部分代码的编写，这正是面向对象编程的思想。这样编写的类被称作“线程安全类”。在设计线程安全类时，首先应根据具体情况在类中加入一个同步对象类数据成员。然后，在类的成员函数中，凡是所有修改公共数据或者读取公共数据的地方均要加入相应的同步调用。一般的处理步骤是：创建一个CSingleLock或者CMultiLock对象，然后调用其Lock函数。当对象结束时，自动在析构函数中调用Unlock函数，当然也可以在任何希望的地方调用Unlock函数。

　　如果不是在特定的C++对象中使用共享资源，而是在特定的函数中使用共享资源（这样的函数称为“线程安全函数”），那么还是按照前面介绍的办法去做：先建立同步对象，然后调用等待函数，直到可以访问资源，最后释放对同步对象的控制。

　　下面我们讨论四个同步对象分别适用的场合：

　　（1）如果某个线程必须等待某些事件发生后才能存取相应资源，则用CEvent；

　　（2）如果一个应用同时可以有多个线程存取相应资源，则用CSemaphore；

　　（3）如果有多个应用(多个进程)同时存取相应资源，则用CMutex，否则用CCriticalSection。

　　使用线程安全类或者线程安全函数进行编程，比不考虑线程安全的编程要复杂，尤其在进行调试时情况更为复杂，我们必须灵活使用Visual C++提供的调试工具，以保证共享资源的安全存取。线程安全编程的另一缺点是运行效率相对要低些，即使在单个线程运行的情况下也会损失一些效率。所以，我们在实际工作中应具体问题具体分析，以选择合适的编程方法。

　　4. 多线程编程例程分析

　　上面讲述了在Visual C++ 5.0中进行多线程编程的技术要点，为了充分说明这种技术，我们来分析一下Visual C++提供的有关多线程的例程，看看一些多线程元素的典型用法。读者可运行这些例程，以获得多线程运行的直观效果。

　　（1）MtRecalc

　　例程MtRecalc的功能是在一个窗口中完成简单的加法运算，用户可输入加数和被加数，例程完成两数相加。用户可通过菜单选择单线程或用辅助线程来做加法运算。如果选择辅助线程进行加法运算，则在进行运算的过程中，用户可继续进行一些界面操作，如访问菜单、编辑数值等，甚至可以中止辅助运算线程。为了使其效果更加明显，例程在计算过程中使用了循环和延时，模拟一个复杂的计算过程。

　　在程序的CRecalcDoc类中，用到了一个线程对象和四个同步事件对象：

　　CWinThread* m_pRecalcWorkerThread;

　　 HANDLE m_hEventStartRecalc;

　　 HANDLE m_hEventRecalcDone;

　　 HANDLE m_hEventKillRecalcThread;

　　 HANDLE m_hEventRecalcThreadKilled;

当用户选择了菜单项Worker Thread后，多线程功能才有效。这时，或者选择菜单项Recalculate Now，或者在窗口中的编辑控制转移焦点时，都会调用函数：

　　void CRecalcDoc::UpdateInt1AndInt2(int n1, int n2, BOOL bForceRecalc);

　　在多线程的情况下，还会调用下面的CRecalcDoc::RecalcInSecondThread函数：

　　void CRecalcDoc::RecalcInSecondThread()

　　{

　　 if (m_pRecalcWorkerThread == NULL)

　　 {

　　 m_pRecalcWorkerThread =

　　 AfxBeginThread(RecalcThreadProc, &m_recalcThreadInfo);

　　 }

　　 m_recalcThreadInfo.m_nInt1 = m_nInt1;

　　 m_recalcThreadInfo.m_nInt2 = m_nInt2;

　　 POSITION pos = GetFirstViewPosition();

　　 CView* pView = GetNextView(pos);

　　 m_recalcThreadInfo.m_hwndNotifyRecalcDone = pView->m_hWnd;

　　 m_recalcThreadInfo.m_hwndNotifyProgress = AfxGetMainWnd()->m_hWnd;

　　 m_recalcThreadInfo.m_nRecalcSpeedSeconds = m_nRecalcSpeedSeconds;

　　 SetEvent(m_hEventRecalcDone);

　　 ResetEvent(m_hEventKillRecalcThread);

　　 ResetEvent(m_hEventRecalcThreadKilled);

　　 SetEvent(m_hEventStartRecalc);

　　}

　　上面加粗的语句是与多线程直接相关的代码，应用程序调用AfxBeginThread启动了线程，把m_recalcThreadInfo作为参数传给线程函数。函数中最后的四行语句设置了四个事件对象的状态，这些事件对象在文档类的构造函数中创建。下面是实际的运算线程函数：

　　UINT RecalcThreadProc(LPVOID pParam)

　　{

　　 CRecalcThreadInfo* pRecalcInfo = (CRecalcThreadInfo*)pParam;

　　 BOOL bRecalcCompleted;

　　 while (TRUE)

　　 {

　　 bRecalcCompleted = FALSE;

　　 if (WaitForSingleObject(pRecalcInfo->m_hEventStartRecalc, INFINITE)

　　 != WAIT_OBJECT_0)

　　 break;

　　 if (WaitForSingleObject(pRecalcInfo->m_hEventKillRecalcThread, 0)

　　 WAIT_OBJECT_0)

　　 break; // Terminate this thread by existing the proc.

　　 ResetEvent(pRecalcInfo->m_hEventRecalcDone);

　　 bRecalcCompleted = SlowAdd(pRecalcInfo->m_nInt1,

　　 pRecalcInfo->m_nInt2,

　　 pRecalcInfo->m_nSum,

　　 pRecalcInfo,

　　 pRecalcInfo->m_nRecalcSpeedSeconds,

　　 pRecalcInfo->m_hwndNotifyProgress);

　　 SetEvent(pRecalcInfo->m_hEventRecalcDone);

　　 if (!bRecalcCompleted) // If interrupted by kill then...

　　 break; // terminate this thread by exiting the proc.

　　 ::PostMessage(pRecalcInfo->m_hwndNotifyRecalcDone, WM_USER_RECALC_DONE, 0, 0);

　　 }

　　 if (!bRecalcCompleted)

　　 SetEvent(pRecalcInfo->m_hEventRecalcThreadKilled);

　　 return 0;

　　 }

　　BOOL SlowAdd(int nInt1, int nInt2, int& nResult, CRecalcThreadInfo* pInfo, int nSeconds,HWND hwndNotifyProgress)

　　{

　　 CWnd* pWndNotifyProgress = CWnd::FromHandle(hwndNotifyProgress);

　　 BOOL bRestartCalculation = TRUE;

　　 while (bRestartCalculation)

　　 {

　　 bRestartCalculation = FALSE;

　　 for (int nCount = 1; nCount <20; nCount++)

　　 {

　　 if (pInfo != NULL

　　 && WaitForSingleObject(pInfo->m_hEventKillRecalcThread, 0) == WAIT_OBJECT_0)

　　 {

　　 if (hwndNotifyProgress != NULL)

　　 {

　　 pWndNotifyProgress->PostMessage( WM_USER_RECALC_IN_PROGRESS);

　　 }

　　 return FALSE; // Terminate this recalculation

　　 }

　　 if (pInfo != NULL

　　 &&WaitForSingleObject(pInfo->m_hEventStartRecalc, 0) == WAIT_OBJECT_0)

　　 {

　　 nInt1 = pInfo->m_nInt1;

　　 nInt2 = pInfo->m_nInt2;

　　 bRestartCalculation = TRUE;

　　 continue;

　　 }

　　 // update the progress indicator

　　 Sleep(nSeconds * 50);

　　 }

　　 // update the progress indicator

　　 }

　　 nResult = nInt1 + nInt2;

　　 return TRUE;

　　}

　　上面的代码充分显示了几个事件对象的用法。当线程刚启动时，先等待m_hEventStartRecalc的状态为允许，然后检查m_hEventKillRecalcThread事件对象的状态。注意这两个等待函数调用的第二个参数的区别：在进入计算函数之前，设置m_hEventRecalcDone事件为不允许状态；待计算结束后，将其设置为允许状态。在计算函数的处理过程中，循环检查事件m_hEventKillRecalcThread和m_hEventStartRecalc的状态，如果m_hEventKillRecalcThread事件允许，则退出线程，中止计算。

　　当计算线程在计算时，主线程可继续接受用户输入（包括菜单选择）。用户可通过菜单项中止计算线程。中止线程的处理比较简单，代码如下：

　　void CRecalcDoc::OnKillWorkerThread()

　　{

　　 SetEvent(m_hEventKillRecalcThread);

　　 SetEvent(m_hEventStartRecalc);

　　 WaitForSingleObject(m_hEventRecalcThreadKilled, INFINITE);

　　 m_pRecalcWorkerThread = NULL;

　　 m_bRecalcInProgress = FALSE; // but m_bRecalcNeeded is still TRUE

　　 UpdateAllViews(NULL, UPDATE_HINT_SUM);

　　}

　　通过设置m_hEventKillRecalcThread事件对象，计算线程的循环就会检测到该事件的状态，最终引起线程的退出。注意：线程的中止因函数的退出而自然中止，而没有用强行办法中止，这样可保证系统的安全性。另外，在程序的很多地方使用了PostMessage来更新计算进度的指示，使用PostMessage函数发送消息可立即返回，无需等待，这样就避免了阻塞，比较符合多线程编程的思想，建议读者使用这种消息发送方法。尤其是在多个UI线程编程时，用这种方法更合适。

　　（2）MtMDI

　　 例程MtMDI是一个MDI应用，每一个子窗口是一个用户接口线程，子窗口里有一个来回弹跳的小球，小球的运动由计时器控制，此处不加以讨论。下面，我们来看看UI线程的创建过程以及它与MDI的结合。

　　通过菜单命令New Bounce，可在主框架窗口类中响应菜单命令，函数代码如下：

　　void CMainFrame::OnBounce()

　　{

　　 CBounceMDIChildWnd *pBounceMDIChildWnd = new CBounceMDIChildWnd;

　　 if (!pBounceMDIChildWnd->Create( _T("Bounce"),

　　 WS_CHILD | WS_VISIBLE | WS_OVERLAPPEDWINDOW, rectDefault, this))

　　 return;

　　}

　　函数调用子框架窗口的创建函数，代码如下：

　　BOOL CBounceMDIChildWnd::Create(LPCTSTR szTitle, LONG style, const RECT& rect, CMDIFrameWnd* parent)

　　{

　　 // Setup the shared menu

　　 if (menu.m_hMenu == NULL)

　　 menu.LoadMenu(IDR_BOUNCE);

　　 m_hMenuShared = menu.m_hMenu;

　　 if (!CMDIChildWnd::Create(NULL, szTitle, style, rect, parent))

　　 return FALSE;

　　 CBounceThread* pBounceThread = new CBounceThread(m_hWnd);

　　 pBounceThread->CreateThread();

　　 return TRUE;

　　}

　　当CBounceMDIChildWnd子窗口被删除时，Windows会同时删除CBounceWnd窗口(内嵌在线程对象pBounceThread中)，因为它是CBounceMDIChildWnd的子窗口。由于CBounceWnd运行在单独的线程中，故当CBounceWnd子窗口被删除时，CWinThread线程对象也会自动被删除。

　　上述函数生成一个新的UI线程对象pBounceThread，并调用CreateThread函数创建线程。至此，线程已被创建，但还需要做初始化工作，如下面的函数InitInstance所示：

　　int CBounceThread::InitInstance()

　　{

　　 CWnd* pParent = CWnd::FromHandle(m_hwndParent);

　　 CRect rect;

　　 pParent->GetClientRect(&rect);

　　 BOOL bReturn = m_wndBounce.Create(_T("BounceMTChildWnd"),WS_CHILD | WS_VISIBLE, rect, pParent);

　　 if (bReturn)

　　 m_pMainWnd = &m_wndBounce;

　　 return bReturn;

　　}

　　注意：这里，将m_pMainWnd设置为新创建的CBounceWnd窗口是必需的。只有这样设置了，才能保证当CBounceWnd窗口被删除时，线程会被自动删除。

　　（3）Mutexes

　　例程Mutexes是一个对话框程序。除主线程外，还有两个线程：一个用于计数，一个用于显示。在本例中，这两个线程都是从CWinThread派生出来的，但并不用于消息循环处理，派生类重载了Run函数，用于完成其计数和显示的任务。

　　在对话框类中使用了一个内嵌的CMutex对象。对话框初始化时创建两个线程，并设置相应的参数，然后启动运行两个线程。

　　当用户设置了对话框的同步检查框标记后，两个线程的同步处理有效。在计数线程的循环中，先调用CSingleLock::Lock函数，然后进行计数修改，最后调用CSingleLock::Unlock函数。注意：这里的CSingleLock对象根据主对话框的CMutex对象产生。在显示线程的循环中，先调用CSingleLock::Lock函数，然后取到计数值，最后调用CSingleLock::Unlock函数。注意：这里的CSingleLock对象也是由主对话框的CMutex对象产生。类似这种情况:一个线程要读取数据，另一个线程要修改数据，这是我们在处理多线程问题时碰到的最典型的情况。此处采用的方法也具有典型意义。源代码可通过查看例程或通过联机帮助来获取。

　　五、结束语

　　多线程函数是Win32不同于Win16的一个重要方面，其编程技术较为新颖，在程序设计思路上不同于传统的模块结构化方法，比一般的面向对象的思路也较为复杂，尤其是对于多处理器平台的处理更为复杂。要设计出性能良好的多线程程序，不仅需要对操作系统的处理过程很清楚，还需要对具体应用有一个全面的认识，并对应用中各线程部分的关系非常清楚，对同步模块中的同步对象的具体含义应尽可能地清晰明了，以利于在程序中控制同步事件的发生，避免出现死锁或不能同步处理的现象。

　　在其它的开发语言（如Visual Basic 5.0）中也提供了对多线程的支持，但从性能和安全的角度考虑，这种多线程支持受到较多的限制。不过，就一般应用而言，用这种处理方法已经足够了。

　　目前，大多数的计算机都是单处理器(CPU)的，在这种机器上运行多线程程序，有时反而会降低系统的性能。如果两个非常活跃的线程为了抢夺对CPU的控制权，则在线程切换时会消耗很多的CPU资源，但对于大部分时间被阻塞的线程（例如等待文件I/O操作），则可用一个单独的线程来完成。这样，就可将CPU时间让出来，使程序获得更好的性能。因此，在设计多线程应用程序时，应慎重选择，并且视具体情况加以处理，使应用程序获得最佳的性能。
　

    符号定义（ Symbol Definition ）伪指令   
    符号定义伪指令用于定义 ARM 汇编程序中的变量、对变量赋值以及定义寄存器的别名等操作。   
    常见的符号定义伪指令有如下几种：   
    — 用于定义全局变量的 GBLA 、 GBLL 和 GBLS 。   
    — 用于定义局部变量的 LCLA 、 LCLL 和 LCLS 。   
    — 用于对变量赋值的 SETA 、 SETL 、 SETS 。   
    — 为通用寄存器列表定义名称的 RLIST 。   
    1、 GBLA、GBLL 和GBLS   
    语法格式：   
    GBLA （ GBLL 或 GBLS ） 全局变量名   
    GBLA 、 GBLL 和 GBLS 伪指令用于定义一个 ARM 程序中的全局变量，并将其初始化。其中：   
    GBLA 伪指令用于定义一个全局的数字变量，并初始化为 0 ；   
    GBLL 伪指令用于定义一个全局的逻辑变量，并初始化为 F （假）；   
    GBLS 伪指令用于定义一个全局的字符串变量，并初始化为空；   
    由于以上三条伪指令用于定义全局变量，因此在整个程序范围内变量名必须唯一。   
    使用示例：   
    GBLA Test1 ；定义一个全局的数字变量，变量名为 Test1   
    Test1 SETA 0xaa ；将该变量赋值为 0xaa   
    GBLL Test2 ；定义一个全局的逻辑变量，变量名为 Test2   
    Test2 SETL {TRUE} ；将该变量赋值为真   
    GBLS Test3 ；定义一个全局的字符串变量，变量名为 Test3   
    Test3 SETS “ Testing ” ；将该变量赋值为 “ Testing ”  

    2、 LCLA、LCLL 和LCLS   
    语法格式：   
    LCLA （ LCLL 或 LCLS ） 局部变量名   
    LCLA 、 LCLL 和 LCLS 伪指令用于定义一个 ARM 程序中的局部变量，并将其初始化。其中：   
    LCLA 伪指令用于定义一个局部的数字变量，并初始化为 0 ；   
    LCLL 伪指令用于定义一个局部的逻辑变量，并初始化为 F （假）；   
    LCLS 伪指令用于定义一个局部的字符串变量，并初始化为空；   
    以上三条伪指令用于声明局部变量，在其作用范围内变量名必须唯一。   
    使用示例：   
    LCLA Test4 ；声明一个局部的数字变量，变量名为 Test4   
    Test3 SETA 0xaa ；将该变量赋值为 0xaa   
    LCLL Test5 ；声明一个局部的逻辑变量，变量名为 Test5   
    Test4 SETL {TRUE} ；将该变量赋值为真   
    LCLS Test6 ；定义一个局部的字符串变量，变量名为 Test6   
    Test6 SETS “ Testing ” ；将该变量赋值为 “ Testing ”   

    3、 SETA、SETL 和SETS   
    语法格式：   
    变量名 SETA （ SETL 或 SETS ） 表达式   
    伪指令 SETA 、 SETL 、 SETS 用于给一个已经定义的全局变量或局部变量赋值。   
    SETA 伪指令用于给一个数学变量赋值；   
    SETL 伪指令用于给一个逻辑变量赋值；   
    SETS 伪指令用于给一个字符串变量赋值；   
    其中，变量名为已经定义过的全局变量或局部变量，表达式为将要赋给变量的值。   
    使用示例：   
    LCLA Test3 ；声明一个局部的数字变量，变量名为 Test3   
    Test3 SETA 0xaa ；将该变量赋值为 0xaa   
    LCLL Test4 ；声明一个局部的逻辑变量，变量名为 Test4   
    Test4 SETL {TRUE} ；将该变量赋值为真   

    4 、 RLIST   
    语法格式：   
    名称 RLIST { 寄存器列表 }   
    RLIST 伪指令可用于对一个通用寄存器列表定义名称，使用该伪指令定义的名称可在 ARM 指令 LDM/STM 中使用。在 LDM/STM 指令中，列表中的寄存器访问次序为根据寄存器的编号由低到高，而与列表中的寄存器排列次序无关。   
    使用示例：   
    RegList RLIST {R0-R5 ， R8 ， R10} ；将寄存器列表名称定义为 RegList ，可在 ARM 指令 LDM/STM中通过该名称访问寄存器列表。   

    数据定义（ Data Definition ）伪指令   
    数据定义伪指令一般用于为特定的数据分配存储单元，同时可完成已分配存储单元的初始化。   
    常见的数据定义伪指令有如下几种：   
    — DCB 用于分配一片连续的字节存储单元并用指定的数据初始化。   
    — DCW （ DCWU ） 用于分配一片连续的半字存储单元并用指定的数据初始化。   
    — DCD （ DCDU ） 用于分配一片连续的字存储单元并用指定的数据初始化。   
    — DCFD （ DCFDU ）用于为双精度的浮点数分配一片连续的字存储单元并用指定的数据初始  
    化。   
    — DCFS （ DCFSU ） 用于为单精度的浮点数分配一片连续的字存储单元并用指定的数据初   
    始化。   
    — DCQ （ DCQU ） 用于分配一片以 8 字节为单位的连续的存储单元并用指定的数据初始   
    化。   
    — SPACE 用于分配一片连续的存储单元   
    — MAP 用于定义一个结构化的内存表首地址   
    — FIELD 用于定义一个结构化的内存表的数据域   
    1、 DCB   
    语法格式：   
    标号 DCB 表达式   
    DCB 伪指令用于分配一片连续的字节存储单元并用伪指令中指定的表达式初始化。其中，表达式可以为 0 ～ 255 的数字或字符串。 DCB 也可用 “ = ” 代替。   
    使用示例：   
    Str DCB “ This is a test ！ ” ；分配一片连续的字节存储单元并初始化。
  
    2、 DCW（或DCWU）   
    语法格式：   
    标号 DCW （或 DCWU ） 表达式   
    DCW （或 DCWU ）伪指令用于分配一片连续的半字存储单元并用伪指令中指定的表达式初始化。   
    其中，表达式可以为程序标号或数字表达式。。   
    用 DCW 分配的字存储单元是半字对齐的，而用 DCWU 分配的字存储单元并不严格半字对齐。   
    使用示例：   
    DataTest DCW 1 ， 2 ， 3 ；分配一片连续的半字存储单元并初始化。   

    3、 DCD（或DCDU）   
    语法格式：   
    标号 DCD （或 DCDU ） 表达式   
    DCD （或 DCDU ）伪指令用于分配一片连续的字存储单元并用伪指令中指定的表达式初始化。其中，表达式可以为程序标号或数字表达式。 DCD 也可用 “ &amp; ” 代替。   
    用 DCD 分配的字存储单元是字对齐的，而用 DCDU 分配的字存储单元并不严格字对齐。   
    使用示例：   
    DataTest DCD 4 ， 5 ， 6 ；分配一片连续的字存储单元并初始化。
  
    4、 DCFD（或DCFDU）   
    语法格式：   
    标号 DCFD （或 DCFDU ） 表达式   
    DCFD （或 DCFDU ）伪指令用于为双精度的浮点数分配一片连续的字存储单元并用伪指令中指定的表达式初始化。每个双精度的浮点数占据两个字单元。用 DCFD 分配的字存储单元是字对齐的，而用 DCFDU 分配的字存储单元并不严格字对齐。   
    使用示例：   
    FDataTest DCFD 2E115 ， -5E7 ；分配一片连续的字存储单元并初始化为指定的双精度数。   

    5、 DCFS（或DCFSU）   
    语法格式：   
    标号 DCFS （或 DCFSU ） 表达式   
    DCFS （或 DCFSU ）伪指令用于为单精度的浮点数分配一片连续的字存储单元并用伪指令中指定的表达式初始化。每个单精度的浮点数占据一个字单元。 用 DCFS 分配的字存储单元是字对齐的，而用 DCFSU 分配的字存储单元并不严格字对齐。   
    使用示例：   
    FDataTest DCFS 2E5 ， -5E － 7 ；分配一片连续的字存储单元并初始化为指定的单精度数。   

    6、 DCQ(或DCQU）   
    语法格式：   
    标号 DCQ （或 DCQU ） 表达式   
    DCQ （或 DCQU ）伪指令用于分配一片以 8 个字节为单位的连续存储区域并用伪指令中指定的表达式初始化。   
    用 DCQ 分配的存储单元是字对齐的，而用 DCQU 分配的存储单元并不严格字对齐。   
    使用示例：   
    DataTest DCQ 100 ；分配一片连续的存储单元并初始化为指定的值。
  
    7、 SPACE   
    语法格式：   
    标号 SPACE 表达式   
    SPACE 伪指令用于分配一片连续的存储区域并初始化为 0 。其中，表达式为要分配的字节数。   
    SPACE 也可用 “ ％ ” 代替。   
    使用示例：   
    DataSpace SPACE 100 ；分配连续 100 字节的存储单元并初始化为 0 。   

    8、 MAP   
    语法格式：   
    MAP 表达式 { ，基址寄存器 }   
    MAP 伪指令用于定义一个结构化的内存表的首地址。 MAP 也可用 “ ＾ ” 代替。   
    表达式可以为程序中的标号或数学表达式，基址寄存器为可选项，当基址寄存器选项不存在时，表达式的值即为内存表的首地址，当该选项存在时，内存表的首地址为表达式的值与基址寄存器的和。   
    MAP 伪指令通常与 FIELD 伪指令配合使用来定义结构化的内存表。   
    使用示例：   
    MAP 0x100 ， R0 ；定义结构化内存表首地址的值为 0x100 ＋ R0 。
  
    9、 FILED   
    语法格式：   
    标号 FIELD 表达式   
    FIELD 伪指令用于定义一个结构化内存表中的数据域。 FILED 也可用 “ # ” 代替。   
    表达式的值为当前数据域在内存表中所占的字节数。   
    FIELD 伪指令常与 MAP 伪指令配合使用来定义结构化的内存表。 MAP 伪指令定义内存表的首地址， FIELD 伪指令定义内存表中的各个数据域，并可以为每个数据域指定一个标号供其他的指令引用。   
    注意 MAP 和 FIELD 伪指令仅用于定义数据结构，并不实际分配存储单元。   
    使用示例：   
    MAP 0x100 ；定义结构化内存表首地址的值为 0x100 。   
    A FIELD 16 ；定义 A 的长度为 16 字节，位置为 0x100   
    B FIELD 32 ；定义 B 的长度为 32 字节，位置为 0x110   
    S FIELD 256 ；定义 S 的长度为 256 字节，位置为 0x130   

    汇编控制（ Assembly Control ）伪指令   
    汇编控制伪指令用于控制汇编程序的执行流程，常用的汇编控制伪指令包括以下几条：   
    — IF 、 ELSE 、 ENDIF   
    — WHILE 、 WEND   
    — MACRO 、 MEND   
    — MEXIT    
    1、 IF、ELSE、ENDIF   
    语法格式：   
    IF 逻辑表达式   
    指令序列 1   
    ELSE   
    指令序列 2   
    ENDIF   
    IF 、 ELSE 、 ENDIF 伪指令能根据条件的成立与否决定是否执行某个指令序列。当 IF 后面的逻辑表达式为真，则执行指令序列 1 ，否则执行指令序列 2 。其中， ELSE 及指令序列 2 可以没有，此时，当 IF 后面的逻辑表达式为真，则执行指令序列 1 ，否则继续执行后面的指令。   
    IF 、 ELSE 、 ENDIF 伪指令可以嵌套使用。   
    使用示例：   
    GBLL Test ；声明一个全局的逻辑变量，变量名为 Test……   
    IF Test = TRUE   
    指令序列 1   
    ELSE   
    指令序列 2   
    ENDIF   

    2、 WHILE、WEND   
    语法格式：   
    WHILE 逻辑表达式   
    指令序列   
    WEND   
    WHILE 、 WEND 伪指令能根据条件的成立与否决定是否循环执行某个指令序列。当 WHILE 后面的逻辑表达式为真，则执行指令序列，该指令序列执行完毕后，再判断逻辑表达式的值，若为真则继续执行，一直到逻辑表达式的值为假。   
    WHILE 、 WEND 伪指令可以嵌套使用。   
    使用示例：   
    GBLA Counter ；声明一个全局的数学变量，变量名为 Counter   
    Counter SETA 3 ；由变量Counter 控制循环次数   
    ……   
    WHILE Counter &lt; 10   
    指令序列   
    WEND   

    3、 MACRO、MEND   
    语法格式：   
    $ 标号 宏名 $ 参数 1 ， $ 参数 2 ，……   
    指令序列   
    MEND   
    MACRO 、 MEND 伪指令可以将一段代码定义为一个整体，称为宏指令，然后就可以在程序中通过宏指令多次调用该段代码。其中， $ 标号在宏指令被展开时，标号会被替换为用户定义的符号， 宏指令可以使用一个或多个参数，当宏指令被展开时，这些参数被相应的值替换。   
    宏指令的使用方式和功能与子程序有些相似，子程序可以提供模块化的程序设计、节省存储空间并提高运行速度。但在使用子程序结构时需要保护现场，从而增加了系统的开销，因此，在代码较短且需要传递的参数较多时，可以使用宏指令代替子程序。   
    包含在 MACRO 和 MEND 之间的指令序列称为宏定义体，在宏定义体的第一行应声明宏的原型（包含宏名、所需的参数），然后就可以在汇编程序中通过宏名来调用该指令序列。在源程序被编译时，汇编器将宏调用展开，用宏定义中的指令序列代替程序中的宏调用，并将实际参数的值传递给宏定义中的形式参数。   
    MACRO 、 MEND 伪指令可以嵌套使用。   

    4、 MEXIT   
    语法格式：   
    MEXIT   
    MEXIT 用于从宏定义中跳转出去。  

    其他常用的伪指令   
    还有一些其他的伪指令，在汇编程序中经常会被使用，包括以下几条：   
    — AREA   
    — ALIGN   
    — CODE16 、 CODE32   
    — ENTRY   
    — END   
    — EQU   
    — EXPORT （或 GLOBAL ）   
    — IMPORT   
    — EXTERN   
    — GET （或 INCLUDE ）   
    — INCBIN   
    — RN   
    — ROUT   
    1、 AREA   
    语法格式：   
    AREA 段名 属性 1 ，属性 2 ，……   
    AREA 伪指令用于定义一个代码段或数据段。其中，段名若以数字开头，则该段名需用 “ | ” 括起来，如 |1_test| 。   
    属性字段表示该代码段（或数据段）的相关属性，多个属性用逗号分隔。常用的属性如下：   
    — CODE 属性：用于定义代码段，默认为 READONLY 。   
    — DATA 属性：用于定义数据段，默认为 READWRITE 。   
    — READONLY 属性：指定本段为只读，代码段默认为 READONLY 。   
    — READWRITE 属性：指定本段为可读可写，数据段的默认属性为 READWRITE 。   
    — ALIGN 属性：使用方式为 ALIGN 表达式。在默认时， ELF （可执行连接文件）的代码段和数据段是按字对齐的，表达式的取值范围为 0 ～ 31 ，相应的对齐方式为 2 表达式次方。   
    — COMMON 属性：该属性定义一个通用的段，不包含任何的用户代码和数据。各源文件中同名的 COMMON 段共享同一段存储单元。   
    一个汇编语言程序至少要包含一个段，当程序太长时，也可以将程序分为多个代码段和数据段。   
    使用示例：   
    AREA Init ， CODE ， READONLY   
    该伪指令定义了一个代码段，段名为 Init ，属性为只读   

    2、 ALIGN   
    语法格式：   
    ALIGN { 表达式 { ，偏移量 }}   
    ALIGN 伪指令可通过添加填充字节的方式，使当前位置满足一定的对其方式 | 。其中，表达式的值用于指定对齐方式，可能的取值为 2 的幂，如 1 、 2 、 4 、 8 、 16 等。若未指定表达式，则将当前位置对齐到下一个字的位置。偏移量也为一个数字表达式，若使用该字段，则当前位置的对齐方式为： 2 的表达式次幂＋偏移量。   
    使用示例：   
    AREA Init ， CODE ， READONLY ， ALIEN ＝ 3 ；指定后面的指令为 8 字节对齐。   
    指令序列   
    END   

    3、 CODE16、CODE32   
    语法格式：   
    CODE16 （或 CODE32 ）   
    CODE16 伪指令通知编译器，其后的指令序列为 16 位的 Thumb 指令。   
    CODE32 伪指令通知编译器，其后的指令序列为 32 位的 ARM 指令。   
    若在汇编源程序中同时包含 ARM 指令和 Thumb 指令时，可用 CODE16 伪指令通知编译器其后的指令序列为 16 位的 Thumb 指令， CODE32 伪指令通知编译器其后的指令序列为 32 位的 ARM 指令。因此，在使用 ARM 指令和 Thumb 指令混合编程的代码里，可用这两条伪指令进行切换，但注意他们只通知编译器其后指令的类型，并不能对处理器进行状态的切换。   
    使用示例：   
    AREA Init ， CODE ， READONLY   
    ……   
    CODE32 ；通知编译器其后的指令为 32 位的 ARM 指令   
    LDR R0 ，＝ NEXT ＋ 1 ；将跳转地址放入寄存器 R0   
    BX R0 ；程序跳转到新的位置执行，并将处理器切换到 Thumb 工作状态   
    ……   
    CODE16 ；通知编译器其后的指令为 16 位的 Thumb 指令   
    NEXT LDR R3，＝0x3FF   
    ……   
    END ；程序结束
  
    4、 ENTRY   
    语法格式：   
    ENTRY   
    ENTRY 伪指令用于指定汇编程序的入口点。在一个完整的汇编程序中至少要有一个 ENTRY （也可以有多个，当有多个 ENTRY 时，程序的真正入口点由链接器指定），但在一个源文件里最多只能有一个 ENTRY （可以没有）。   
    使用示例：   
    AREA Init ， CODE ， READONLY   
    ENTRY ；指定应用程序的入口点   
    ……   

    5、 END   
    语法格式：   
    END   
    END 伪指令用于通知编译器已经到了源程序的结尾。   
    使用示例：   
    AREA Init ， CODE ， READONLY   
    ……   
    END ；指定应用程序的结尾   

    6、 EQU   
    语法格式：   
    名称 EQU 表达式 { ，类型 }   
    EQU 伪指令用于为程序中的常量、标号等定义一个等效的字符名称，类似于 C 语言中的＃ define 。   
    其中 EQU 可用 “ * ” 代替。   
    名称为 EQU 伪指令定义的字符名称，当表达式为 32 位的常量时，可以指定表达式的数据类型，可以有以下三种类型：   
    CODE16 、 CODE32 和 DATA   
    使用示例：   
    Test EQU 50 ；定义标号 Test 的值为 50   
    Addr EQU 0x55 ， CODE32 ；定义 Addr 的值为 0x55 ，且该处为 32 位的 ARM 指令。   

    7、 EXPORT（或GLOBAL）   
    语法格式：   
    EXPORT 标号 {[WEAK]}   
    EXPORT 伪指令用于在程序中声明一个全局的标号，该标号可在其他的文件中引用。 EXPORT可用 GLOBAL 代替。标号在程序中区分大小写， [WEAK] 选项声明其他的同名标号优先于该标号被引用。   
    使用示例：   
    AREA Init ， CODE ， READONLY   
    EXPORT Stest ；声明一个可全局引用的标号Stest……   
    END   

    8、 IMPORT   
    语法格式：   
    IMPORT 标号 {[WEAK]}   
    IMPORT 伪指令用于通知编译器要使用的标号在其他的源文件中定义，但要在当前源文件中引用，而且无论当前源文件是否引用该标号，该标号均会被加入到当前源文件的符号表中。   
    标号在程序中区分大小写， [WEAK] 选项表示当所有的源文件都没有定义这样一个标号时，编译器也不给出错误信息，在多数情况下将该标号置为 0 ，若该标号为 B 或 BL 指令引用，则将 B 或 BL指令置为 NOP 操作。   
    使用示例：   
    AREA Init ， CODE ， READONLY   
    IMPORT Main ；通知编译器当前文件要引用标号Main，但Main 在其他源文件中定义……   
    END   

    9、 EXTERN   
    语法格式：   
    EXTERN 标号 {[WEAK]}   
    EXTERN 伪指令用于通知编译器要使用的标号在其他的源文件中定义，但要在当前源文件中引用，如果当前源文件实际并未引用该标号，该标号就不会被加入到当前源文件的符号表中。标号在程序中区分大小写， [WEAK] 选项表示当所有的源文件都没有定义这样一个标号时，编译器也不给出错误信息，在多数情况下将该标号置为 0 ，若该标号为 B 或 BL 指令引用，则将 B 或 BL指令置为 NOP 操作。   
    使用示例：   
    AREA Init ， CODE ， READONLY   
    EXTERN Main ；通知编译器当前文件要引用标号Main，但Main 在其他源文件中定义……   
    END   

    10、 GET（或INCLUDE）   
    语法格式：   
    GET 文件名   
    GET 伪指令用于将一个源文件包含到当前的源文件中，并将被包含的源文件在当前位置进行汇编处理。可以使用 INCLUDE 代替 GET 。   
    汇编程序中常用的方法是在某源文件中定义一些宏指令，用 EQU 定义常量的符号名称，用 MAP和 FIELD 定义结构化的数据类型，然后用 GET 伪指令将这个源文件包含到其他的源文件中。使用方法与 C 语言中的 “ include ” 相似。   
    GET 伪指令只能用于包含源文件，包含目标文件需要使用 INCBIN 伪指令   
    使用示例：   
    AREA Init ， CODE ， READONLY   
    GET a1.s ；通知编译器当前源文件包含源文件a1.s   
    GE T C：\a2.s ；通知编译器当前源文件包含源文件C：\ a2.s ……   
    END   

    11、 INCBIN   
    语法格式：   
    INCBIN 文件名   
    INCBIN 伪指令用于将一个目标文件或数据文件包含到当前的源文件中，被包含的文件不作任何变动的存放在当前文件中，编译器从其后开始继续处理。   
    使用示例：   
    AREA Init ， CODE ， READONLY   
    INCBIN a1.dat ；通知编译器当前源文件包含文件a1.dat   
    INCBIN C：\a2.txt ；通知编译器当前源文件包含文件C：\a2.txt……   
    END   

    12、 RN   
    语法格式：   
    名称 RN 表达式   
    RN 伪指令用于给一个寄存器定义一个别名。采用这种方式可以方便程序员记忆该寄存器的功能。其中，名称为给寄存器定义的别名，表达式为寄存器的编码。   
    使用示例：   
    Temp RN R0 ；将R0 定义一个别名Temp   

    13、 ROUT   
    语法格式：   
    { 名称 } ROUT   
    ROUT 伪指令用于给一个局部变量定义作用范围。在程序中未使用该伪指令时，局部变量的作用范围为所在的 AREA ，而使用 ROUT 后，局部变量的作为范围为当前 ROUT 和下一个 ROUT 之间。

【1】tic,toc                        %这方法最简单，但一定要一起执行，

tic                                           %否则显示的是tic和toc两条命令的间隔时间

your_operation

toc

【2】cputime                    %给一个变量设定为cputime，做操作，然后看这个时间变了多少，

t=cputime;                            % 但如果时间太小就显示0

your_operation

cputime-t

【3】clock,etime                          %和上面类似

t0 = clock;
your_operation
etime(clock,t0)

三种网络方式

BRIDGED:  

NAT：

Host-only:

CString str;
//获取系统时间
CTime tm;
tm=CTime::GetCurrentTime();
str=tm.Format("现在时间是%Y年%m月%d日 %X");
MessageBox(str,NULL,MB_OK);

2: 得到系统时间日期(使用GetLocalTime)

SYSTEMTIME st;
CString strDate,strTime;
GetLocalTime(&st);
strDate.Format("%4d-%2d-%2d",st.wYear,st.wMonth,st.wDay);
strTime.Format("%2d:%2d:%2d",st.wHour,st.wMinute,st.wSecond);

3.使用GetTickCount
//获取程序运行时间
long t1=GetTickCount();//程序段开始前取得系统运行时间(ms)
Sleep(500);
long t2=GetTickCount();();//程序段结束后取得系统运行时间(ms)
str.Format("time:%dms",t2-t1);//前后之差即 程序运行时间
AfxMessageBox(str);
//获取系统运行时间
long t=GetTickCount();
CString str,str1;
str1.Format("系统已运行 %d时",t/3600000);
str=str1;
t%=3600000;
str1.Format("%d分",t/60000);
str+=str1;
t%=60000;
str1.Format("%d秒",t/1000);
str+=str1;
AfxMessageBox(str);

如何在VC6.0中得到一个程序的运行时间，也就是这个程序耗费的时钟周期数// C和C++的时间编程

#include<iostream>
#include<ctime>
using namespace std;
int main()
{
time_t begin,end;
begin=clock();
//这里加上你的代码
end=clock();
cout<<"runtime: "<<double(end-begin)/CLOCKS_PER_SEC<<endl;
}   
   

unix时间相关,也是标准库的
这些在<time.h>
1.timegm函数只是将struct tm结构转成time_t结构,不使用时区信息;
time_t timegm(struct tm *tm);

2.mktime使用时区信息
time_t mktime(struct tm *tm);

timelocal 函数是GNU扩展的与posix函数mktime相当
time_t timelocal (struct tm *tm);

3.gmtime函数只是将time_t结构转成struct tm结构,不使用时区信息;
struct tm * gmtime(const time_t *clock);

4.localtime使用时区信息
struct tm * localtime(const time_t *clock);

1.time获取时间，stime设置时间
time_t t；
t = time(&t);
2.stime其参数应该是GMT时间,根据本地时区设置为本地时间;
int stime(time_t *tp)

3.UTC=true 表示采用夏时制;
4.文件的修改时间等信息全部采用GMT时间存放,不同的系统在得到修改时间后通过localtime转换成本地时间;
5.设置时区推荐使用setup来设置;
6.设置时区也可以先更变/etc/sysconfig/clock中的设置 再将ln -fs /usr/share/zoneinfo/xxxx/xxx /etc/localtime 才能重效

time_t只能表示68年的范围，即mktime只能返回1970-2038这一段范围的time_t
看看你的系统是否有time_t64，它能表示更大的时间范围

Window里面的一些不一样的

CTime MFC类，好像就是把time.h封了个类，没扩展
CTime t = GetCurrentTime();

SYSTEMTIME 结构包含毫秒信息
typedef struct _SYSTEMTIME {
WORD wYear;
WORD wMonth;
WORD wDayOfWeek;
WORD wDay;
WORD wHour;
WORD wMinute;
WORD wSecond;
WORD wMilliseconds;
} SYSTEMTIME, *PSYSTEMTIME;

SYSTEMTIME t1;
GetSystemTime(&t1)
CTime curTime(t1);
WORD ms = t1.wMilliseconds;

SYSTEMTIME sysTm;
::GetLocalTime(&sysTm);

在time.h中的_strtime() //只能在windows中用
char t[11];
_strtime(t);
puts(t);

------------------------------------------------------------------------------
_timeb定义在SYS\TIMEB.H，有四个fields
dstflag
millitm
time
timezone

void _ftime( struct _timeb *timeptr );

struct _timeb timebuffer;
   _ftime( &timebuffer );
取当前时间:文档讲可以到ms,有人测试,好象只能到16ms!

-------------------------------------------------------------------------
如何设定当前系统时间---windows
SYSTEMTIME m_myLocalTime,*lpSystemTime;
    m_myLocalTime.wYear=2003;
    m_myLocalTime.wMonth=1;
    m_myLocalTime.wDay=1;
    m_myLocalTime.wHour=0;
    m_myLocalTime.wMinute=0;
    m_myLocalTime.wSecond=0;
    m_myLocalTime.wMilliseconds=0;
    lpSystemTime=&m_myLocalTime;
    if( SetLocalTime(lpSystemTime) ) //此处换成 SetSystemTime( )也不行
       MessageBox("OK !");
    else
       MessageBox("Error !");

SYSTEMTIME m_myLocalTime,*lpSystemTime;
m_myLocalTime.wYear=2003;
m_myLocalTime.wMonth=1;
m_myLocalTime.wDay=1;
lpSystemTime=&m_myLocalTime;
if( SetDate(lpSystemTime) ) //此处换成 SetSystemTime( )也不行
    MessageBox("OK !");
else
    MessageBox("Error !");

-----------------------------------------------------------------------------
用clock()函数，得到系统启动以后的毫秒级时间，然后除以CLOCKS_PER_SEC，就可以换成“秒”，标准c函数。
clock_t clock ( void );

#include <time.h>
clock_t t = clock();
long sec = t / CLOCKS_PER_SEC;
他是记录时钟周期的，实现看来不会很精确，需要试验验证；

---------------------------------------------------------------------------
据说tc2.0的time结构含有毫秒信息
#include   <stdio.h>
#include   <dos.h>

int main(void)
{
   struct time t;

   gettime(&t);
   printf("The current time is: %2d:%02d:%02d.%02d\n",
          t.ti_hour, t.ti_min, t.ti_sec, t.ti_hund);
   return 0;
}
time 是一个结构体，， 其中成员函数 ti_hund 是豪秒。。。上程序可以在tc2.0运行

--------------------------------------------------------------------------------
这个是windows里面常用来计算程序运行时间的函数；
DWORD dwStart = GetTickCount();

//这里运行你的程序代码

DWORD dwEnd = GetTickCount();

则(dwEnd-dwStart)就是你的程序运行时间, 以毫秒为单位
这个函数只精确到55ms，1个tick就是55ms。

--------------------------------------------------------------------------------
timeGetTime()基本等于GetTickCount()，但是精度更高
DWORD dwStart = timeGetTime();

//这里运行你的程序代码

DWORD dwEnd = timeGetTime();

则(dwEnd-dwStart)就是你的程序运行时间, 以毫秒为单位
虽然返回的值单位应该是ms,但传说精度只有10ms。
--------------------------------------------------------------------------------

Borland C++ Builder VCL的时间函数

　　1. Date
　　返回TDateTime对象,包含当前的年月日信息,函数原型如下：
　　System：：TDateTime __fastcall Date(void)；

　　2. Time
　　返回TDateTime对象,包含当前的时间信息,函数原型如下：
　　System：：TDateTime __fastcall Time(void)；

　　3. Now
　　返回TDateTime对象,获取当前的日期和时间信息,函数原型如下：
　　System：：TDateTime __fastcall Now(void)；

　　4. DatetimeToString
　　将TDateTime对象转换为指定格式的字符串对象,函数原型如下：
　　void __fastcall DateTimeToString(AnsiString &；Result, const AnsiString Format,System：：TDateTime DateTime)；

　　5. DateToStr
　　将TDateTime对象(包含当前年月日信息)转换为字符串对象,函数原型如下：
　　AnsiString __fastcall DateToStr(System：：TDateTime Date)；

　　6. TimeToStr
　　将当前日期转换为字符串对象,函数原型如下：
　　AnsiString __fastcall TimeToStr(System：：TDateTime Time)；

　　7. DateTimetoStr
　　将TDateTime对象转换为字符串对象,函数原型如下：
　　AnsiString __fastcall DateTimeToStr(System：：TDateTime DateTime)；

　　8. StrToDate
　　将字符串对象转换为年月日对象,函数原型如下：
　　System：：TDateTime __fastcall StrToDate(const AnsiString S)；

　　9. StrToTime
　　将字符串对象转换时间对象,函数原型如下：
　　System：：TDateTime __fastcall StrToTime(const AnsiString S)；

　　10.StrToDateTime
　　将字符串对象转换为年月日时间对象,函数原型如下：
　　System：：TDateTime __fastcall StrToDateTime(const AnsiString S)；

　　11.DateTimeToSystemTime
　　将TDateTime对象转换为操作系统时间,函数原型如下：
　　void __fastcall DateTimeToSystemTime(System：：TDateTime DateTime, _SYSTEMTIME &；SystemTime)；

　　12.SystemTimeToDateTime
　　将操作系统时间转换为TDateTime对象,函数原型如下：
　　System：：TDateTime __fastcall SystemTimeToDateTime(const _SYSTEMTIME &；SystemTime)；

---------------------------------------------------------------------------------------
下面是转的一个用汇编的精确计时方法
---------------------------------------------------------------------------------------
如何获得程序或者一段代码运行的时间？你可能说有专门的程序测试工具，确实，不过你也可以在程序中嵌入汇编代码来实现。

在Pentium的指令系统中有一条指令可以获得CPU内部64位计数器的值，我们可以通过代码两次获取该计数器的值而获得程序或代码运行的时钟周期数，进而通过你的cpu的频率算出一个时钟周期的时间，从而算出程序运行的确切时间。

我们通过指令TDSIC来获得cpu内部计数器的值,指令TDSIC返回值放在EDX:EAX中,其中EDX中存放64位寄存器中高32位的值,EAX存放第32位的值.

下面看看实现的代码:

//用汇编实现获取一段代码运行的时间
#include<iostream>

using namespace std;

void GetClockNumber (long high, long low);
void GetRunTime();

int main()
{   

long HighStart,LowStart,HighEnd,LowEnd;
long numhigh,numlow;
//获取代码运行开始时cpu内部计数器的值
__asm       
{
RDTSC
mov HighStart, edx
mov LowStart, eax
}
for(int i= 0; i<100000; i++ )
{
       for(int i= 0; i<100000; i++ )
   {
   
   }

}
//获取代码结束时cpu内部计数器的值，并减去初值
    __asm
{
RDTSC
mov HighEnd, edx
Mov LowEnd, eax
;获取两次计数器值得差
sub eax, LowStart
cmp eax, 0    ; 如果低32的差为负则求返,因为第二次取得永远比第一次的大
jg   L1
neg   eax
jmp   L2
      L1: mov numlow, eax
      L2: sbb edx, HighStart
mov numhigh, edx

}
    //把两个计数器值之差放在一个64位的整形变量中
    //先把高32位左移32位放在64的整形变量中,然后再加上低32位
__int64 timer =(numhigh<<32) + numlow;
     //输出代码段运行的时钟周期数
     //以频率1.1Gcpu为例,如果换计算机把其中的1.1改乘其它即可,因为相信大家的cpu都应该在1G以上 ^_^
cout<< (double) (timer /1.1/1000000000) << endl;
return 0;
}

   这样通过一条简单的汇编指令就可以获得程序或一段代码的大概时间，不过并不能得到运行的确切时间，因为即使去掉中间的循环，程序也会有个运行时间，

因为在第一次取得计数器的值后，有两条汇编指令mov HighStart, edx    mov LowStart, eax这两条指令当然也有运行时间 ，当然你可以减去这两条指令的运行时间(在1.1G的机子上是3e-8s)，这样会更精确一点。

如果你要确切知道程序的运行时间，专业的测试软件肯定会更好一点，不过好像一般没有必要获取除非专门的要求的程序。

A： 用函数whos。

Q2：如何解决matlab7.0命令窗口跳出一大堆java错误...

A：换matlab 7的sp2。

Q3：自从安装matlab，一开机就在进程里有matlab。

    能不能开机的时候进程就不运行matlab？

A： 开始-->控制面板-->管理工具-->服务

    把MATLAB Server的属性改成“手动”就行了。

Q4：退出matlab7程序运行的快捷键。

A： ctrl+q

Q5：matlab7远程控制是否有限制？

A：不能远程控制,不过你可以先在你的remote机器上打开,然后就可以用了。

Q6：Matlab占用资源太多怎么办？

A： 用matlab -nojvm启动（如果不需要图形界面）。

Q7：怎样给matlab添加新的toolbox？

A： 在matlab的文件菜单里边添加路径，选set path。

Q8：请问matlab有没有命令可以调出历史输入啊？

A： command history 窗口。

Q9：matlab 7.0 不能在64位的cpu下运行？

A： matlab 应该是依赖于自己的虚拟机的

    但是好像这个虚拟机是在 IA32 里面作出来的，所以，应该找个带 64 位的

    java 虚拟机替换原来的，不过不一定能行 or so,记不清了）

Q10：matlab有没有注释一段的功能？

A： 选中一段代码，ctrl r就是区段注释

     选中一段代码，ctrl t取消区段注释

Q11：今有WINDOWS版MATLAB7，启动时只出现版权画面，然后进程结束。

A:   用matlab -nojvm可以启动，但是报了OpenGL错误的信息，估计是显卡比较

     差或驱动程序不好。在显示属性里关闭硬件加速即可。

                          matlab常用命令参考

1、学会用help和doc函数。

2、输入输出文件：save/load

   在屏幕上显示文件：type

3、解线性方程组AX=B：X=A\B

4、作图时两张曲线合并：hold on或者subplot作子图

5、程序计算时间：tic，toc或者clock

6、变量显示方式更改：format long/short/bank...

7、数组元素求和：sum

8、求数组长度：length

   求矩阵维数：size或者ndims 矩阵元素个数：numel

9、函数作图：

   饼图：pie/pie3    误差图：errorbar     散点图：scatter/scatter3

   直方图：hist      函数图：fplot        动画：movie

10、矩阵分析：

    左右翻转：fliplr    上下翻转：flipud    转置：transpose

    矩阵求逆：inv       矩阵范数：norm      条件数：cond

    初等变换：rref      特征值：eig/eigs

11、特殊矩阵：

    元素全为1的矩阵：ones          元素全为0的矩阵：zeros

    单位阵：eye                    魔方阵：magic

    线性变化数组：linspace         聚合矩阵：cat/horzcat/vertcat

12、随机数：

    创建一个元素服从均匀分布的随机数数组：rand

    创建一个元素服从正态分布的随机数数组：randn

    二项分布：binornd 指数分布：exprnd       F分布：frnd

    几何分布：geornd   超几何分布：hygernd    泊松分布：poissrnd

    正态分布：normrnd 离散均匀分布：unidrnd 连续均匀分布：unifrnd

13、清屏：clc 清理内存：clear

14、字体显示变更等：preferences

15、得到一个文件夹的所有文件名：ls

16、语句太长的话可以再句末加...换行。

                     matlab与其他软件调用问题集锦

Q1：如何在c++里可以调用matlab6.5的数学库？

A： 6.5版的第三张cd里的cppmath_ug2b.pdf、cppmath_ref2b.pdf

    比较详细的介绍了Matlab C++ Math Library

Q2：matlab的库能生成c代码吗？

A： 库就是compile过，等着被其它程序link的，

    即能得到效率又能隐藏算法，都放在matlab安装目录的\extern\lib;\bin\win32

    下面要看算法的话，就查阅help，一般会简单地介绍下算法，或者用到的文献什

    么的。库是帮你写好的算法，用就可以了:)

Q3：关于matlab中的xlsread函数

A：这个函数可以读出excel数据。先把excel里面数据复制粘贴到记事本，

    再textread进去。

Q4：请问如何在matlab中插入c代码？

A：需要把c代码编译成mex文件，需要把c代码编译成mex文件。

    6.5版的第三张cd里的apiext.pdf、apiref.pdf介绍了怎么把c代码编译成mex。

Q5：如何将excel数据导入matlab?

A： ExcelLink。

Q6：java如何和matlab互相调用？

A： matlab环境（完整环境）内置了java虚拟机，所以普通的java类都可以在matlab环境

    中直接使用。

    事实上matlab很多程序例如界面，还有数据库借口，都是由java创建的。

    关于java与matlab数据的交互，帮助上讲的比较清楚。

                       matlab插值与拟合问题集锦

Q1：就是给出几个点，要求一个给定阶数的多项式，使他最接近这几个点。类似?[0m

    线性回归。

A： [a,S]=polyfit(x,y,n)

    [ye,delta]=ployval(a,x,S)

    %a为所得的多项式系数

Q2：如何做最简单的一维拟合？

A： yy=spline(x,y,xx)

                       matlab图形与图象问题集锦

Q1：比如一个函数C(x,y,z)，想做一个3维等值面图，该如何做？

A： help contour3/help uicontrol 在plot出来的figure上做个小控件吧。

Q2：请问怎么把MATLAB里用程序实现的动画导入到Powerpoint演示呢？

A： matlab有avifile,getframe,addframe,pause等做avi动画的函数的。

    做好的avi放在ppt，如果要暂停之类的功能，是ppt或者播放器的事情了。

    matlab提供了com组件来和其它应用程序进行通信在ppt里写个vba调用matlab。

    细节可以在help文档里查找vba和com关键字

Q3：我们可以用subplot画出两个不同的曲面图，那怎么样才能使得这两个曲面图

    各自用到不同的颜色对照表呢？如果画完一个然后用不同的colormap，

    两张图会变成一样的。

A：如果是曲面图的话 atch对象或者surface对象自己有颜色映射表的。

    其实说白了，colormap也是对颜色的索引罢了，例如surface对象而言，也就是第

    三位的颜色表。支持的形式有两种:索引以及RGB直接表示.采用第二种就可以解决

    这个问题.毕竟对于figure对象而言,colormap没有太大的意义.

    以下附实现的方法,以供讨论: （见合集2005年之38）

    原理是通过改变caxis的值。

Q4：虽然用subplot可以在一个窗口中显示多幅图像，但是每幅图像之间有较大间距。

    现在想让多幅图像紧挨着显示(比如说2行两列共4个图像)，该如何实现？

A： subplot('Position',[left bottom width height])

    或者axes('PropertyName',PropertyValue,...)

Q5：matlab 怎么画球？

A： sphere函数。

Q6：matlab由图上直接取某个值命令？

A：ginput。

Q7：请问用什么命令可以让figure窗口中的图形输出到指定的文件中？

    图片数量很大。

A： print和matlab 的 notebook 功能

Q8：怎么能让一个plot命令执行完了以后重新开一个chart window画下一个图？

A： figure。

Q9：请教matlab坐标不等距画图。如果坐标轴上标的量希望不要均匀应该怎么操作？

A： semilogy/xtick,ytick。

Q10：如何在matlab中接摄像头自动获取图像?

A:   比较简单的是调用现成的Activex、Com控件来完成，缺点是至今无法编译。

     第二种是自己写硬件接口，优点是可以编译，并且自定功能，缺点是耗时。

Q11：请问matlab绘图能有动态效果吗？

A： 延时、清屏、重画。ing like that

     如果闪烁的话打开double buffer

     高兴的话还可以做成avi movie(frame2avi or so）

     还有慧星图 comet

Q12：怎么样更改colorbar中的字体？

A： colorbar说白了就是一个axes对象.

     这样:了傅幕按蚩猟ouble buffer

     ColorbarHandle = colorbar ;(frame2avi or so）

     set(ColorbarHandle, 'FontSize', 20);

Q13：请问matlab中画多张图如何使用同一的colorbar?

A： z值映射到colormap，colorbar通过z值和colormap的映射关系生成的，所以需要

     将不同的figure，z值映射相同的colormap索引。

Q14：在MATLAB里如何显示一副图像，但使其背景为透明的？

A： 用 image 画了之后再把 axis 关掉（axis off）

                       matlab运筹与统计问题集锦

Q1：在matlab7.0中求解线形规划的函数？

A： linprog一般能直接给出结果，参数设定可参阅help。

Q2：matlab中如何做回归分析？

A： Statistics Toolbox。

Q3：已知两个正态分布的均值和方差，matlab里有什么函数可以直接求出来？

A： 用fminsearch函数。

Q4：已知两个变量符合一个联合正态分布参数，能否用matlab生成这两个随机数？

A：先生成两个独立正态随机数，然后利用正态分布的性质，用线性变换过去。

    也可参阅statistics toolbox中类似于 multirnd 还是什么

Q5：求解一个不等式外加两个约束条件用什么函数好呢？

A：试试用规划中的fmincon函数。