第一篇：多线程编程知识总结
多线程编程
一、问题的提出
1.1问题的引出
编写一个耗时的单线程程序：
新建一个基于对话框的应用程序SingleThread，在主对话框IDD_SINGLETHREAD_DIALOG添加一个按钮，ID为IDC_SLEEP_SIX_SECOND，标题为“延时6秒”，添加按钮的响应函数，代码如下：
void CSingleThreadDlg::OnSleepSixSecond(){ Sleep(6000);//延时6秒 } 编译并运行应用程序，单击“延时6秒”按钮，你就会发现在这6秒期间程序就象“死机”一样，不在响应其它消息。为了更好地处理这种耗时的操作，我们有必要学习——多线程编程。
1.2多线程概述
进程和线程都是操作系统的概念。进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它各种系统资源组成，进程在运行过程中创建的资源随着进程的终止而被销毁，所使用的系统资源在进程终止时被释放或关闭。
线程是进程内部的一个执行单元。系统创建好进程后，实际上就启动执行了该进程的主执行线程，主执行线程以函数地址形式，比如说main或WinMain函数，将程序的启动点提供给Windows系统。主执行线程终止了，进程也就随之终止。
每一个进程至少有一个主执行线程，它无需由用户去主动创建，是由系统自动创建的。用户根据需要在应用程序中创建其它线程，多个线程并发地运行于同一个进程中。一个进程中的所有线程都在该进程的虚拟地址空间中，共同使用这些虚拟地址空间、全局变量和系统资源，所以线程间的通讯非常方便，多线程技术的应用也较为广泛。
多线程可以实现并行处理，避免了某项任务长时间占用CPU时间。要说明的一点是，对于单处理器（CPU）的，为了运行所有这些线程，操作系统为每个独立线程安排一些CPU时间，操作系统以轮换方式向线程提供时间片，这就给人一种假象，好象这些线程都在同时运行。由此可见，如果两个非常活跃的线程为了抢夺对CPU的控制权，在线程切换时会消耗很多的CPU资源，反而会降低系统的性能。这一点在多线程编程时应该注意。
Win32 SDK函数支持进行多线程的程序设计，并提供了操作系统原理中的各种同步、互斥和临界区等操作。Visual C++中，使用MFC类库也实现了多线程的程序设计，使得多线程编程更加方便。1.3 Win32 API对多线程编程的支持
Win32 提供了一系列的API函数来完成线程的创建、挂起、恢复、终结以及通信等工作。下面将选取其中的一些重要函数进行说明。
1、HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes，DWORD dwStackSize，LPTHREAD_START_ROUTINE lpStartAddress，LPVOID lpParameter，DWORD dwCreationFlags，LPDWORD lpThreadId);该函数在其调用进程的进程空间里创建一个新的线程，并返回已建线程的句柄，其中各参数说明如下：
lpThreadAttributes：指向一个 SECURITY_ATTRIBUTES 结构的指针，该结构决定了线程的安全属性，一般置为 NULL；
dwStackSize：指定了线程的堆栈深度，一般都设置为0；
lpStartAddress：表示新线程开始执行时代码所在函数的地址，即线程的起始地址。一般情况为(LPTHREAD_START_ROUTINE)ThreadFunc，ThreadFunc 是线程函数名；
lpParameter：指定了线程执行时传送给线程的32位参数，即线程函数的参数；
dwCreationFlags：控制线程创建的附加标志，可以取两种值。如果该参数为0，线程在被创建后就会立即开始执行；如果该参数为CREATE_SUSPENDED,则系统产生线程后，该线程处于挂起状态，并不马上执行，直至函数ResumeThread被调用；
lpThreadId：该参数返回所创建线程的ID；
如果创建成功则返回线程的句柄，否则返回NULL。
2、DWORD SuspendThread(HANDLE hThread);该函数用于挂起指定的线程，如果函数执行成功，则线程的执行被终止。
3、DWORD ResumeThread(HANDLE hThread);该函数用于结束线程的挂起状态，执行线程。
4、VOID ExitThread(DWORD dwExitCode);该函数用于线程终结自身的执行，主要在线程的执行函数中被调用。其中参数dwExitCode用来设置线程的退出码。
5、BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode);
一般情况下，线程运行结束之后，线程函数正常返回，但是应用程序可以调用TerminateThread强行终止某一线程的执行。各参数含义如下： hThread：将被终结的线程的句柄；
dwExitCode：用于指定线程的退出码。
使用TerminateThread()终止某个线程的执行是不安全的，可能会引起系统不稳定；虽然该函数立即终止线程的执行，但并不释放线程所占用的资源。因此，一般不建议使用该函数。
6、BOOL PostThreadMessage(DWORD idThread，UINT Msg，WPARAM wParam，LPARAM lParam);该函数将一条消息放入到指定线程的消息队列中，并且不等到消息被该线程处理时便返回。idThread：将接收消息的线程的ID；
Msg：指定用来发送的消息；
wParam：同消息有关的字参数；
lParam：同消息有关的长参数；
调用该函数时，如果即将接收消息的线程没有创建消息循环，则该函数执行失败。
1.4.Win32 API多线程编程例程
例程1 [MultiThread1] 一个简单的线程。注意事项：
Volatile:关键字：
volatile是要求C++编译器不要自作聪明的把变量缓冲在寄存器里.因为该变量可能会被意外的修改。(多个线程或其他原因)
如从串口读数据的场合,把变量缓冲在寄存器里,下次去读寄存器就没有意义了.因为串口的数据可能随时会改变的.加锁访问用于多个线程的场合.在进入临界区时是肯定要加锁的.volatile也加上，以保证从内存中读取变量的值. 终止线程：
Windows终止线程运行的四种方法 终止线程运行
若要终止线程的运行，可以使用下面的方法：
• 线程函数返回（最好使用这种方法）。
• 通过调用 ExitThread 函数，线程将自行撤消（最好不要使用这种方法）。
• 同一个进程或另一个进程中的线程调用 TerminateThread 函数（应该避免使用这种方法）。
• 包含线程的进程终止运行（应该避免使用这种方法）。
下面将介绍终止线程运行的方法，并且说明线程终止运行时会出现什么情况。
线程函数返回
始终都应该将线程设计成这样的形式，即当想要线程终止运行时，它们就能够返回。这是确保所有线程资源被正确地清除的唯一办法。
如果线程能够返回，就可以确保下列事项的实现：
• 在线程函数中创建的所有 C++ 对象均将通过它们的撤消函数正确地撤消。
• 操作系统将正确地释放线程堆栈使用的内存。
• 系统将线程的退出代码（在线程的内核对象中维护）设置为线程函数的返回值。
• 系统将递减线程内核对象的使用计数。 使用 ExitThread 函数
可以让线程调用 ExitThread 函数，以便强制线程终止运行：
VOID ExitThread(DWORD dwExitCode);
该函数将终止线程的运行，并导致操作系统清除该线程使用的所有操作系统资源。但是，C++ 资源（如 C++ 类对象）将不被撤消。由于这个原因，最好从线程函数返回，而不是通过调用 ExitThread 来返回。
当然，可以使用 ExitThread 的 dwExitThread 参数告诉系统将线程的退出代码设置为什么。ExitThread 函数并不返回任何值，因为线程已经终止运行，不能执行更多的代码。 使用 TerminateThread 函数
调用 TerminateThread 函数也能够终止线程的运行：
BOOL TerminateThread(HANDLE hThread, DWORD dwExitCode);
与 ExitThread 不同，ExitThread 总是撤消调用的线程，而 TerminateThread 能够撤消任何线程。hThread 参数用于标识被终止运行的线程的句柄。当线程终止运行时，它的退出代码成为你作为 dwExitCode 参数传递的值。同时，线程的内核对象的使用计数也被递减。
注意 TerminateThread 函数是异步运行的函数，也就是说，它告诉系统你想要线程终止运行，但是，当函数返回时，不能保证线程被撤消。如果需要确切地知道该线程已经终止运行，必须调用 WaitForSingleObject 或者类似的函数，传递线程的句柄。
设计良好的应用程序从来不使用这个函数，因为被终止运行的线程收不到它被撤消的通知。线程不能正确地清除，并且不能防止自己被撤消。
注意 当使用返回或调用 ExitThread 的方法撤消线程时，该线程的内存堆栈也被撤消。但是，如果使用 TerminateThread，那么在拥有线程的进程终止运行之前，系统不撤消该线程的堆栈。Microsoft故意用这种方法来实现 TerminateThread。如果其他仍然正在执行的线程要引用强制撤消的线程堆栈上的值，那么其他的线程就会出现访问违规的问题。如果将已经撤消的线程的堆栈留在内存中，那么其他线程就可以继续很好地运行。
此外，当线程终止运行时，DLL 通常接收通知。如果使用 TerminateThread 强迫线程终止，DLL 就不接收通知，这能阻止适当的清除，在进程终止运行时撤消线程。当线程终止运行时，会发生下列操作：
• 线程拥有的所有用户对象均被释放。在 Windows 中，大多数对象是由包含创建这些对象的线程的进程拥有的。但是一个线程拥有两个用户对象，即窗口和挂钩。当线程终止运行时，系统会自动撤消任何窗口，并且卸载线程创建的或安装的任何挂钩。其他对象只有在拥有线程的进程终止运行时才被撤消。
• 线程的退出代码从 STILL_ACTIVE 改为传递给 ExitThread 或 TerminateThread 的代码。
• 线程内核对象的状态变为已通知。
• 如果线程是进程中最后一个活动线程，系统也将进程视为已经终止运行。
• 线程内核对象的使用计数递减 1。
当一个线程终止运行时，在与它相关联的线程内核对象的所有未结束的引用关闭之前，该内核对象不会自动被释放。
一旦线程不再运行，系统中就没有别的线程能够处理该线程的句柄。然而别的线程可以调用 GetExitcodeThread 来检查由 hThread 标识的线程是否已经终止运行。如果它已经终止运行，则确定它的退出代码：
BOOL GetExitCodeThread(HANDLE hThread, PDOWRD pdwExitCode);退出代码的值在 pdwExitCode 指向的 DWORD 中返回。如果调用 GetExitCodeThread 时线程尚未终止运行，该函数就用 STILL_ACTIVE 标识符（定义为 0x103）填入 DWORD。如果该函数运行成功，便返回 TRUE。
线程的定义：
例程2[MultiThread2] 传送一个一个整型的参数到一个线程中，以及如何等待一个线程完成处理。
DWORD WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);
hHandle：为要监视的对象（一般为同步对象，也可以是线程）的句柄；
dwMilliseconds：为hHandle对象所设置的超时值，单位为毫秒；
当在某一线程中调用该函数时，线程暂时挂起，系统监视hHandle所指向的对象的状态。如果在挂起的dwMilliseconds毫秒内，线程所等待的对象变为有信号状态，则该函数立即返回；如果超时时间已经到达dwMilliseconds毫秒，但hHandle所指向的对象还没有变成有信号状态，函数照样返回。参数dwMilliseconds有两个具有特殊意义的值：0和INFINITE。若为0，则该函数立即返回；若为INFINITE，则线程一直被挂起，直到hHandle所指向的对象变为有信号状态时为止。
例程3[MultiThread3] 传送一个结构体给一个线程函数，可以通过传送一个指向结构体的指针参数来完成。补充一点：如果你在void CMultiThread3Dlg::OnStart()函数中添加/* */语句，编译运行你就会发现进度条不进行刷新，主线程也停止了反应。什么原因呢？这是因为WaitForSingleObject函数等待子线程（ThreadFunc）结束时，导致了线程死锁。因为WaitForSingleObject函数会将主线程挂起（任何消息都得不到处理），而子线程ThreadFunc正在设置进度条，一直在等待主线程将刷新消息处理完毕返回才会检测通知事件。这样两个线程都在互相等待，死锁发生了，编程时应注意避免。
例程4[MultiThread4] 测试在Windows下最多可创建线程的数目。
二、MFC中的多线程开发
2.1 MFC对多线程编程的支持
MFC中有两类线程，分别称之为工作者线程和用户界面线程。二者的主要区别在于工作者线程没有消息循环，而用户界面线程有自己的消息队列和消息循环。
工作者线程没有消息机制，通常用来执行后台计算和维护任务，如冗长的计算过程，打印机的后台打印等。用户界面线程一般用于处理独立于其他线程执行之外的用户输入，响应用户及系统所产生的事件和消息等。但对于Win32的API编程而言，这两种线程是没有区别的，它们都只需线程的启动地址即可启动线程来执行任务。
在MFC中，一般用全局函数AfxBeginThread()来创建并初始化一个线程的运行，该函数有两种重载形式，分别用于创建工作者线程和用户界面线程。两种重载函数原型和参数分别说明如下：
(1)CWinThread* AfxBeginThread(AFX_THREADPROC pfnThreadProc，LPVOID pParam，nPriority=THREAD_PRIORITY_NORMAL，UINT nStackSize=0，DWORD dwCreateFlags=0，LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);
PfnThreadProc：指向工作者线程的执行函数的指针，线程函数原型必须声明如下： UINT ExecutingFunction(LPVOID pParam);请注意，ExecutingFunction()应返回一个UINT类型的值，用以指明该函数结束的原因。一般情况下，返回0表明执行成功。
pParam：传递给线程函数的一个32位参数，执行函数将用某种方式解释该值。它可以是数值，或是指向一个结构的指针，甚至可以被忽略；
nPriority：线程的优先级。如果为0，则线程与其父线程具有相同的优先级；
nStackSize：线程为自己分配堆栈的大小，其单位为字节。如果nStackSize被设为0，则线程的堆栈被设置成与父线程堆栈相同大小； dwCreateFlags：如果为0，则线程在创建后立刻开始执行。如果为CREATE_SUSPEND，则线程在创建后立刻被挂起；
lpSecurityAttrs：线程的安全属性指针，一般为NULL；
(2)CWinThread* AfxBeginThread(CRuntimeClass* pThreadClass，int nPriority=THREAD_PRIORITY_NORMAL，UINT nStackSize=0，DWORD dwCreateFlags=0，LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);
pThreadClass 是指向 CWinThread 的一个导出类的运行时类对象的指针，该导出类定义了被创建的用户界面线程的启动、退出等；其它参数的意义同形式1。使用函数的这个原型生成的线程也有消息机制，在以后的例子中我们将发现同主线程的机制几乎一样。下面对CWinThread类的数据成员及常用函数进行简要说明。
m_hThread：当前线程的句柄；
m_nThreadID:当前线程的ID；
m_pMainWnd：指向应用程序主窗口的指针
virtual BOOL CWinThread::InitInstance();重载该函数以控制用户界面线程实例的初始化。初始化成功则返回非0值，否则返回0。用户界面线程经常重载该函数，工作者线程一般不使用InitInstance()。
virtual int CWinThread::ExitInstance();在线程终结前重载该函数进行一些必要的清理工作。该函数返回线程的退出码，0表示执行成功，非0值用来标识各种错误。同InitInstance()成员函数一样，该函数也只适用于用户界面线程。
2.2 MFC多线程编程实例
例程5 MultiThread5 为了与Win32 API对照，使用MFC 类库编程实现例程3 MultiThread3。
例程6 MultiThread6[用户界面线程] 创建用户界面线程的步骤：
1.使用ClassWizard创建类CWinThread的派生类（以CUIThread类为例）class CUIThread : public CWinThread { DECLARE_DYNCREATE(CUIThread)protected: CUIThread();// protected constructor used by dynamic creation
// Attributes public: // Operations public:
// Overrides // ClassWizard generated virtual function overrides //{{AFX_VIRTUAL(CUIThread)public: virtual BOOL InitInstance();virtual int ExitInstance();//}}AFX_VIRTUAL // Implementation protected: virtual ~CUIThread();// Generated message map functions //{{AFX_MSG(CUIThread)
// NOTE-the ClassWizard will add and remove member functions here.//}}AFX_MSG
DECLARE_MESSAGE_MAP()};
2.重载函数InitInstance()和ExitInstance()。BOOL CUIThread::InitInstance(){ CFrameWnd* wnd=new CFrameWnd;wnd->Create(NULL,“UI Thread Window”);wnd->ShowWindow(SW_SHOW);wnd->UpdateWindow();m_pMainWnd=wnd;return TRUE;}
3.创建新的用户界面线程 void CUIThreadDlg::OnButton1(){
}
请注意以下两点：
A、在UIThreadDlg.cpp的开头加入语句： #include “UIThread.h” B、把UIThread.h中类CUIThread()的构造函数的特性由 protected 改为 public。CUIThread* pThread=new CUIThread();pThread->CreateThread();
用户界面线程的执行次序与应用程序主线程相同，首先调用用户界面线程类的InitInstance()函数，如果返回TRUE，继续调用线程的Run()函数，该函数的作用是运行一个标准的消息循环，并且当收到WM_QUIT消息后中断，在消息循环过程中，Run()函数检测到线程空闲时（没有消息），也将调用OnIdle()函数，最后Run()函数返回，MFC调用ExitInstance()函数清理资源。
你可以创建一个没有界面而有消息循环的线程，例如：你可以从CWinThread派生一个新类，在InitInstance函数中完成某项任务并返回FALSE，这表示仅执行InitInstance函数中的任务而不执行消息循环，你可以通过这种方法，完成一个工作者线程的功能。
三、线程间通讯
3.1通讯方式
一般而言,应用程序中的一个次要线程总是为主线程执行特定的任务,这样,主线程和次要线程间必定有一个信息传递的渠道,也就是主线程和次要线程间要进行通信。这种线程间的通信不但是难以避免的，而且在多线程编程中也是复杂和频繁的，下面将进行说明。
3.1.1使用全局变量进行通信
由于属于同一个进程的各个线程共享操作系统分配该进程的资源，故解决线程间通信最简单的一种方法是使用全局变量。对于标准类型的全局变量，建议使用volatile 修饰符，它告诉编译器无需对该变量作任何的优化，即无需将它放到一个寄存器中，并且该值可被外部改变。如果线程间所需传递的信息较复杂，可以定义一个结构，通过传递指向该结构的指针进行传递信息。
3.1.2使用自定义消息
可以在一个线程的执行函数中向另一个线程发送自定义的消息来达到通信的目的。一个线程向另外一个线程发送消息是通过操作系统实现的。利用Windows操作系统的消息驱动机制，当一个线程发出一条消息时，操作系统首先接收到该消息，然后把该消息转发给目标线程，接收消息的线程必须已经建立了消息循环。
3.2例程
例程GlobalObjectTest 该例程演示了如何利用全局变量进行通信
例程7[MultiThread7] 该例程演示了如何使用自定义消息进行线程间通信。首先，主线程向CCalculateThread线程发送消息WM_CALCULATE，CCalculateThread线程收到消息后进行计算，再向主线程发送WM_DISPLAY消息，主线程收到该消息后显示计算结果。步骤：
四、线程的同步
4.1基本概念
虽然多线程能给我们带来好处，但是也有不少问题需要解决。例如，对于像磁盘驱动器这样独占性系统资源，由于线程可以执行进程的任何代码段，且线程的运行是由系统调度自动完成的，具有一定的不确定性，因此就有可能出现两个线程同时对磁盘驱动器进行操作，从而出现操作错误；又例如，对于银行系统的计算机来说，可能使用一个线程来更新其用户数据库，而用另外一个线程来读取数据库以响应储户的需要，极有可能读数据库的线程读取的是未完全更新的数据库，因为可能在读的时候只有一部分数据被更新过。
使隶属于同一进程的各线程协调一致地工作称为线程的同步。MFC提供了多种同步对象，下面只介绍最常用的四种：
临界区（CCriticalSection）
事件（CEvent）
互斥量（CMutex）
信号量（CSemaphore）
通过这些类，可以比较容易地做到线程同步。
4.2使用 CCriticalSection 类
当多个线程访问一个独占性共享资源时,可以使用“临界区”对象。任一时刻只有一个线程可以拥有临界区对象，拥有临界区的线程可以访问被保护起来的资源或代码段，其他希望进入临界区的线程将被挂起等待，直到拥有临界区的线程放弃临界区时为止，这样就保证了不会在同一时刻出现多个线程访问共享资源。
CCriticalSection类的用法非常简单，步骤如下：
1.定义CCriticalSection类的一个全局对象（以使各个线程均能访问），如CCriticalSection critical_section；
2.在访问需要保护的资源或代码之前，调用CCriticalSection类的成员Lock（）获得临界区对象： critical_section.Lock();3.在线程中调用该函数来使线程获得它所请求的临界区。如果此时没有其它线程占有临界区对象，则调用Lock()的线程获得临界区；否则，线程将被挂起，并放入到一个系统队列中等待，直到当前拥有临界区的线程释放了临界区时为止。
4.访问临界区完毕后，使用CCriticalSection的成员函数Unlock()来释放临界区：critical_section.Unlock();通俗讲，就是线程A执行到critical_section.Lock();语句时，如果其它线程(B)正在执行critical_section.Lock();语句后且critical_section.Unlock();语句前的语句时，线程A就会等待，直到线程B执行完critical_section.Unlock();语句，线程A才会继续执行。
例程8 MultiThread8 4.3使用 CEvent 类
CEvent 类提供了对事件的支持。事件是一个允许一个线程在某种情况发生时，唤醒另外一个线程的同步对象。例如在某些网络应用程序中，一个线程（记为A）负责监听通讯端口，另外一个线程（记为B）负责更新用户数据。通过使用CEvent 类，线程A可以通知线程B何时更新用户数据。每一个CEvent 对象可以有两种状态：有信号状态和无信号状态。线程监视位于其中的CEvent 类对象的状态，并在相应的时候采取相应的操作。
在MFC中，CEvent 类对象有两种类型：人工事件和自动事件。一个自动CEvent 对象在被至少一个线程释放后会自动返回到无信号状态；而人工事件对象获得信号后，释放可利用线程，但直到调用成员函数ReSetEvent()才将其设置为无信号状态。在创建CEvent 类的对象时，默认创建的是自动事件。CEvent 类的各成员函数的原型和参数说明如下：
1、CEvent(BOOL bInitiallyOwn=FALSE，BOOL bManualReset=FALSE，LPCTSTR lpszName=NULL，LPSECURITY_ATTRIBUTES lpsaAttribute=NULL);bInitiallyOwn：指定事件对象初始化状态，TRUE为有信号，FALSE为无信号；
bManualReset：指定要创建的事件是属于人工事件还是自动事件。TRUE为人工事件，FALSE为自动事件；
后两个参数一般设为NULL，在此不作过多说明。
2、BOOL CEvent：：SetEvent();
将 CEvent 类对象的状态设置为有信号状态。如果事件是人工事件，则 CEvent 类对象保持为有信号状态，直到调用成员函数ResetEvent()将 其重新设为无信号状态时为止。如果CEvent 类对象为自动事件，则在SetEvent()将事件设置为有信号状态后，CEvent 类对象由系统自动重置为无信号状态。
如果该函数执行成功，则返回非零值，否则返回零。
3、BOOL CEvent：：ResetEvent();
该函数将事件的状态设置为无信号状态，并保持该状态直至SetEvent()被调用时为止。由于自动事件是由系统自动重置，故自动事件不需要调用该函数。如果该函数执行成功，返回非零值，否则返回零。一般通过调用WaitForSingleObject函数来监视事件状态。前面已经介绍了该函数。由于语言描述的原因，CEvent 类的理解确实有些难度，只要通过下面例程，多看几遍就可理解。例程9 MultiThread9 仔细分析这两个线程函数, 就会正确理解CEvent 类。线程WriteD执行到 WaitForSingleObject(eventWriteD.m_hObject,INFINITE);处等待，直到事件eventWriteD为有信号该线程才往下执行，因为eventWriteD对象是自动事件，则当WaitForSingleObject()返回时，系统自动把eventWriteD对象重置为无信号状态。
4.4使用CMutex 类
互斥对象与临界区对象很像.互斥对象与临界区对象的不同在于:互斥对象可以在进程间使用,而临界区对象只能在同一进程的各线程间使用。当然，互斥对象也可以用于同一进程的各个线程间，但是在这种情况下，使用临界区会更节省系统资源，更有效率。
4.5使用CSemaphore 类
当需要一个计数器来限制可以使用某个线程的数目时，可以使用“信号量”对象。CSemaphore 类的对象保存了对当前访问某一指定资源的线程的计数值，该计数值是当前还可以使用该资源的线程的数目。如果这个计数达到了零，则所有对这个CSemaphore 类对象所控制的资源的访问尝试都被放入到一个队列中等待，直到超时或计数值不为零时为止。一个线程被释放已访问了被保护的资源时，计数值减1；一个线程完成了对被控共享资源的访问时，计数值增1。这个被CSemaphore 类对象所控制的资源可以同时接受访问的最大线程数在该对象的构建函数中指定。
CSemaphore 类的构造函数原型及参数说明如下：
CSemaphore(LONG lInitialCount=1，LONG lMaxCount=1，LPCTSTR pstrName=NULL，LPSECURITY_ATTRIBUTES lpsaAttributes=NULL);lInitialCount：信号量对象的初始计数值，即可访问线程数目的初始值；
lMaxCount：信号量对象计数值的最大值，该参数决定了同一时刻可访问由信号量保护的资源的线程最大数目；
后两个参数在同一进程中使用一般为NULL，不作过多讨论；
在用CSemaphore 类的构造函数创建信号量对象时要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时，则说明当前占用资源的线程数已经达到了所允许的最大数目，不能再允许其它线程的进入，此时的信号量信号将无法发出。线程在处理完共享资源后，应在离开的同时通过ReleaseSemaphore()函数将当前可用资源数加1。例程10 MultiThread10 为了文件中能够正确使用同步类，在文件开头添加： #include “afxmt.h” 定义信号量对象和一个字符数组，为了能够在不同线程间使用，定义为全局变量：CSemaphore semaphoreWrite(2,2);//资源最多访问线程2个，当前可访问线程数2个
在信号量对象有信号的状态下，线程执行到WaitForSingleObject语句处继续执行，同时可用线程数减1；若线程执行到WaitForSingleObject语句时信号量对象无信号，线程就在这里等待，直到信号量对象有信号线程才往下执行。
第二篇：Java多线程编程总结
Java多线程编程总结
2007-05-17 11:21:59 标签：java 多线程
原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处、作者信息和本声明。否则将追究法律责任。http://lavasoft.blog.51cto.com/62575/27069
Java多线程编程总结
下面是Java线程系列博文的一个编目：
Java线程：概念与原理 Java线程：创建与启动
Java线程：线程栈模型与线程的变量 Java线程：线程状态的转换 Java线程：线程的同步与锁 Java线程：线程的交互 Java线程：线程的调度-休眠 Java线程：线程的调度-优先级 Java线程：线程的调度-让步 Java线程：线程的调度-合并 Java线程：线程的调度-守护线程 Java线程：线程的同步-同步方法 Java线程：线程的同步-同步块
Java线程：并发协作-生产者消费者模型 Java线程：并发协作-死锁 Java线程：volatile关键字 Java线程：新特征-线程池
Java线程：新特征-有返回值的线程 Java线程：新特征-锁（上）Java线程：新特征-锁（下）Java线程：新特征-信号量 Java线程：新特征-阻塞队列 Java线程：新特征-阻塞栈 Java线程：新特征-条件变量 Java线程：新特征-原子量 Java线程：新特征-障碍器 Java线程：大总结
----
下面的内容是很早之前写的，内容不够充实，而且是基于Java1.4的内容，Java5之后，线程并发部分扩展了相当多的内容，因此建议大家看上面的系列文章的内容，与时俱进，跟上Java发展的步伐。----
一、认识多任务、多进程、单线程、多线程 要认识多线程就要从操作系统的原理说起。
以前古老的DOS操作系统（V 6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来批量执行任务。
现在的操作系统都是多任务操作系统，每个运行的任务就是操作系统所做的一件事情，比如你在听歌的同时还在用MSN和好友聊天。听歌和聊天就是两个任务，这个两个任务是“同时”进行的。一个任务一般对应一个进程，也可能包含好几个进程。比如运行的MSN就对应一个MSN的进程，如果你用的是windows系统，你就可以在任务管理器中看到操作系统正在运行的进程信息。
一般来说，当运行一个应用程序的时候，就启动了一个进程，当然有些会启动多个进程。启动进程的时候，操作系统会为进程分配资源，其中最主要的资源是内存空间，因为程序是在内存中运行的。在进程中，有些程序流程块是可以乱序执行的，并且这个代码块可以同时被多次执行。实际上，这样的代码块就是线程体。线程是进程中乱序执行的代码流程。当多个线程同时运行的时候，这样的执行模式成为并发执行。
多线程的目的是为了最大限度的利用CPU资源。
Java编写程序都运行在在Java虚拟机（JVM）中，在JVM的内部，程序的多任务是通过线程来实现的。每用java命令启动一个java应用程序，就会启动一个JVM进程。在同一个JVM进程中，有且只有一个进程，就是它自己。在这个JVM环境中，所有程序代码的运行都是以线程来运行。
一般常见的Java应用程序都是单线程的。比如，用java命令运行一个最简单的HelloWorld的Java应用程序时，就启动了一个JVM进程，JVM找到程序程序的入口点main()，然后运行main()方法，这样就产生了一个线程，这个线程称之为主线程。当main方法结束后，主线程运行完成。JVM进程也随即退出。
对于一个进程中的多个线程来说，多个线程共享进程的内存块，当有新的线程产生的时候，操作系统不分配新的内存，而是让新线程共享原有的进程块的内存。因此，线程间的通信很容易，速度也很快。不同的进程因为处于不同的内存块，因此进程之间的通信相对困难。
实际上，操作的系统的多进程实现了多任务并发执行，程序的多线程实现了进程的并发执行。多任务、多进程、多线程的前提都是要求操作系统提供多任务、多进程、多线程的支持。
在Java程序中，JVM负责线程的调度。线程调度是值按照特定的机制为多个线程分配CPU的使用权。调度的模式有两种：分时调度和抢占式调度。分时调度是所有线程轮流获得CPU使用权，并平均分配每个线程占用CPU的时间；抢占式调度是根据线程的优先级别来获取CPU的使用权。JVM的线程调度模式采用了抢占式模式。
所谓的“并发执行”、“同时”其实都不是真正意义上的“同时”。众所周知，CPU都有个时钟频率，表示每秒中能执行cpu指令的次数。在每个时钟周期内，CPU实际上只能去执行一条（也有可能多条）指令。操作系统将进程线程进行管理，轮流（没有固定的顺序）分配每个进程很短的一段是时间（不一定是均分），然后在每个线程内部，程序代码自己处理该进程内部线程的时间分配，多个线程之间相互的切换去执行，这个切换时间也是非常短的。因此多任务、多进程、多线程都是操作系统给人的一种宏观感受，从微观角度看，程序的运行是异步执行的。
用一句话做总结：虽然操作系统是多线程的，但CPU每一时刻只能做一件事，和人的大脑是一样的，呵呵。
二、Java与多线程
Java语言的多线程需要操作系统的支持。
Java 虚拟机允许应用程序并发地运行多个执行线程。Java语言提供了多线程编程的扩展点，并给出了功能强大的线程控制API。
在Java中，多线程的实现有两种方式： 扩展java.lang.Thread类 实现java.lang.Runnable接口
每个线程都有一个优先级，高优先级线程的执行优先于低优先级线程。每个线程都可以或不可以标记为一个守护程序。当某个线程中运行的代码创建一个新 Thread 对象时，该新线程的初始优先级被设定为创建线程的优先级，并且当且仅当创建线程是守护线程时，新线程才是守护程序。
当 Java 虚拟机启动时，通常都会有单个非守护线程（它通常会调用某个指定类的 main 方法）。Java 虚拟机会继续执行线程，直到下列任一情况出现时为止：
调用了 Runtime 类的 exit 方法，并且安全管理器允许退出操作发生。
非守护线程的所有线程都已停止运行，无论是通过从对 run 方法的调用中返回，还是通过抛出一个传播到 run 方法之外的异常。
三、扩展java.lang.Thread类
/** * File Name: TestMitiThread.java * Created by: IntelliJ IDEA.* Copyright: Copyright(c)2003-2006 * Company: Lavasoft([url]http://lavasoft.blog.51cto.com/[/url])* Author: leizhimin * Modifier: leizhimin * Date Time: 2007-5-17 10:03:12 * Readme: 通过扩展Thread类实现多线程 */ public class TestMitiThread { public static void main(String[] rags){ System.out.println(Thread.currentThread().getName()+ “ 线程运行开始!”);new MitiSay(“A”).start();new MitiSay(“B”).start();System.out.println(Thread.currentThread().getName()+ “ 线程运行结束!”);} }
class MitiSay extends Thread { public MitiSay(String threadName){ super(threadName);}
public void run(){ System.out.println(getName()+ “ 线程运行开始!”);for(int i = 0;i < 10;i++){ System.out.println(i + “ ” + getName());try { sleep((int)Math.random()* 10);} catch(InterruptedException e){ e.printStackTrace();} } System.out.println(getName()+ “ 线程运行结束!”);} }
运行结果：
main 线程运行开始!main 线程运行结束!A 线程运行开始!0 A 1 A B 线程运行开始!2 A 0 B 3 A 4 A 1 B 5 A 6 A 7 A 8 A 9 A A 线程运行结束!2 B 3 B 4 B 5 B 6 B 7 B 8 B 9 B B 线程运行结束!说明：
程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用MitiSay的两个对象的start方法，另外两个线程也启动了，这样，整个应用就在多线程下运行。
在一个方法中调用Thread.currentThread().getName()方法，可以获取当前线程的名字。在mian方法中调用该方法，获取的是主线程的名字。
注意：start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。
从程序运行的结果可以发现，多线程程序是乱序执行。因此，只有乱序执行的代码才有必要设计为多线程。
Thread.sleep()方法调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留出一定时间给其他线程执行的机会。
实际上所有的多线程代码执行顺序都是不确定的，每次执行的结果都是随机的。
四、实现java.lang.Runnable接口
/** * 通过实现 Runnable 接口实现多线程 */ public class TestMitiThread1 implements Runnable {
public static void main(String[] args){ System.out.println(Thread.currentThread().getName()+ “ 线程运行开始!”);TestMitiThread1 test = new TestMitiThread1();Thread thread1 = new Thread(test);Thread thread2 = new Thread(test);thread1.start();thread2.start();System.out.println(Thread.currentThread().getName()+ “ 线程运行结束!”);}
public void run(){ System.out.println(Thread.currentThread().getName()+ “ 线程运行开始!”);for(int i = 0;i < 10;i++){ System.out.println(i + “ ” + Thread.currentThread().getName());try { Thread.sleep((int)Math.random()* 10);} catch(InterruptedException e){ e.printStackTrace();} } System.out.println(Thread.currentThread().getName()+ “ 线程运行结束!”);} }
运行结果：
main 线程运行开始!Thread-0 线程运行开始!main 线程运行结束!0 Thread-0 Thread-1 线程运行开始!0 Thread-1 1 Thread-1 1 Thread-0 2 Thread-0 2 Thread-1 3 Thread-0 3 Thread-1 4 Thread-0 4 Thread-1 5 Thread-0 6 Thread-0 5 Thread-1 7 Thread-0 8 Thread-0 6 Thread-1 9 Thread-0 7 Thread-1 Thread-0 线程运行结束!8 Thread-1 9 Thread-1 Thread-1 线程运行结束!说明：
TestMitiThread1类通过实现Runnable接口，使得该类有了多线程类的特征。run（）方法是多线程程序的一个约定。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target)构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。
五、读解Thread类API
static int MAX_PRIORITY 线程可以具有的最高优先级。static int MIN_PRIORITY 线程可以具有的最低优先级。static int NORM_PRIORITY 分配给线程的默认优先级。
构造方法摘要
Thread(Runnable target)分配新的 Thread 对象。Thread(String name)分配新的 Thread 对象。
方法摘要
static Thread currentThread()返回对当前正在执行的线程对象的引用。ClassLoader getContextClassLoader()返回该线程的上下文 ClassLoader。long getId()返回该线程的标识符。String getName()返回该线程的名称。int getPriority()返回线程的优先级。Thread.State getState()返回该线程的状态。ThreadGroup getThreadGroup()返回该线程所属的线程组。static boolean holdsLock(Object obj)当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。void interrupt()中断线程。
static boolean interrupted()测试当前线程是否已经中断。boolean isAlive()测试线程是否处于活动状态。boolean isDaemon()测试该线程是否为守护线程。boolean isInterrupted()测试线程是否已经中断。void join()等待该线程终止。void join(long millis)等待该线程终止的时间最长为 millis 毫秒。void join(long millis, int nanos)等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。void resume()已过时。该方法只与 suspend()一起使用，但 suspend()已经遭到反对，因为它具有死锁倾向。有关更多信息，请参阅为何 Thread.stop、Thread.suspend 和 Thread.resume 遭到反对？。void run()如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。void setContextClassLoader(ClassLoader cl)设置该线程的上下文 ClassLoader。void setDaemon(boolean on)将该线程标记为守护线程或用户线程。
static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)设置当线程由于未捕获到异常而突然终止，并且没有为该线程定义其他处理程序时所调用的默认处理程序。void setName(String name)改变线程名称，使之与参数 name 相同。void setPriority(int newPriority)更改线程的优先级。
void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)设置该线程由于未捕获到异常而突然终止时调用的处理程序。static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。static void sleep(long millis, int nanos)在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行）。void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。void stop()已过时。该方法具有固有的不安全性。用 Thread.stop 来终止线程将释放它已经锁定的所有监视器（作为沿堆栈向上传播的未检查 ThreadDeath 异常的一个自然后果）。如果以前受这些监视器保护的任何对象都处于一种不一致的状态，则损坏的对象将对其他线程可见，这有可能导致任意的行为。stop 的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代。目标线程应定期检查该变量，并且如果该变量指示它要停止运行，则从其运行方法依次返回。如果目标线程等待很长时间（例如基于一个条件变量），则应使用 interrupt 方法来中断该等待。有关更多信息，请参阅《为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？》。void stop(Throwable obj)已过时。该方法具有固有的不安全性。请参阅 stop()以获得详细信息。该方法的附加危险是它可用于生成目标线程未准备处理的异常（包括若没有该方法该线程不太可能抛出的已检查的异常）。有关更多信息，请参阅为何 Thread.stop、Thread.suspend 和 Thread.resume 遭到反对？。void suspend()已过时。该方法已经遭到反对，因为它具有固有的死锁倾向。如果目标线程挂起时在保护关键系统资源的监视器上保持有锁，则在目标线程重新开始以前任何线程都不能访问该资源。如果重新开始目标线程的线程想在调用 resume 之前锁定该监视器，则会发生死锁。这类死锁通常会证明自己是“冻结”的进程。有关更多信息，请参阅为何 Thread.stop、Thread.suspend 和 Thread.resume 遭到反对？。String toString()返回该线程的字符串表示形式，包括线程名称、优先级和线程组。static void yield()暂停当前正在执行的线程对象，并执行其他线程。
六、线程的状态转换图
线程在一定条件下，状态会发生变化。线程变化的状态转换图如下：
1、新建状态（New）：新创建了一个线程对象。
2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
七、线程的调度
1、调整线程优先级：Java线程有优先级，优先级高的线程会获得较多的运行机会。
Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量： static int MAX_PRIORITY 线程可以具有的最高优先级，取值为10。static int MIN_PRIORITY 线程可以具有的最低优先级，取值为1。static int NORM_PRIORITY 分配给线程的默认优先级，取值为5。
Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。
每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM_PRIORITY。
线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同的优先级。JVM提供了10个线程优先级，但与常见的操作系统都不能很好的映射。如果希望程序能移植到各个操作系统中，应该仅仅使用Thread类有以下三个静态常量作为优先级，这样能保证同样的优先级采用了同样的调度方式。
2、线程睡眠：Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。
3、线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0)一样。
4、线程让步：Thread.yield()方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。
5、线程加入：join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。
6、线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。注意：Thread中suspend()和resume()两个方法在JDK1.5中已经废除，不再介绍。因为有死锁倾向。
7、常见线程名词解释
主线程：JVM调用程序mian()所产生的线程。
当前线程：这个是容易混淆的概念。一般指通过Thread.currentThread()来获取的进程。后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的垃圾回收线程就是一个后台线程。
前台线程：是指接受后台线程服务的线程，其实前台后台线程是联系在一起，就像傀儡和幕后操纵者一样的关系。傀儡是前台线程、幕后操纵者是后台线程。由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。
本文出自 “熔 岩” 博客，请务必保留此出处http://lavasoft.blog.51cto.com/62575/27069
第三篇：C++编程知识总结
1.数组
1.1数组定义时的注意点
1在C++中不提供可变化大小的数组，○即数组定义中的常量表达式不能包含变量。（来源：C++书6.1.1）
int n;cin>>n;float t[n];上例在定义数组t时，变量n没有确定的值，即在程序执行之前，无法知道数组t的元素个数，所以这种声明不被允许。但是可以用new动态分配,如： int n;cin>>n;float *t;t=new float[n];
2在定义数组时，可以不直接指定数组的大小，由C++编译器根据初值表中元素的个数来自○动确定数组元素的个数。例如： int z[]={0,1,2,3,4,5,6,7,8} 3C++语言规定只能对数组中的元素进行赋值或引用，不能把整个数组作为一个整体进行赋○值或引用。（2.3是一个实例）（来源：C++书4同类型的数组之间不能相互赋值 ○如int a[5],b[5];a=b;//错误
strcpy(b,a);//正确
6.1.1）
1.2数组和指针的关系（来源：C++书8.2节8.2.1）
char s[5];在C++中说明了一个数组后，数组名可以作为一个指针来使用，因此s可作为一个指针使用（但它不同于指针,不能赋值运算、算术运算等）。
2.字符数组
2.1输入字符数据 char c;cin>>c;// cin不能将输入的空格赋给字符型变量。
cin.get();//可获得键盘上输入的每一个字符，包括空格和回车键。
2.2字符数组的输入/输出（来源：C++书6.2.4）2.2.1逐个字符输入 char c[10];for(int i=0;i<10;i++)cin>>c[i];2.2.2字符串输入 方法1 char c[10];cin>>c;//即在输入输出时只给数组名
此法在输入字符串时，遇到空格和回车就认为一个字符结束。方法2 cin.getline(字符数组名，允许输入的最大字符个数)此法可把输入的一行作为一个字符串送到字符数组中。
2.3字符数组和字符指针的初始化 2.3.1字符数组初始化 char tx[5]=“";2.3.2字符指针初始化 char *ptx=new char[5];ptx[0]=' ';2.4字符串赋值
方法1 char tx[4]=”abcd“;方法2 char tx[4];//tx=”abcd“;//错误，tx是数组名，不分配内存空间，不可以进行赋值操作；但是数组名可当指针使用（C++书8.2.1）。strcpy(tx,”abcd“);以上两种方法是数组
方法3是指向数组的指针方法 方法3 char *tx;tx=new char[4];tx=”abcd“ 方法4 char *tx=”abcde“;//这相当于根据数组元素的个数，确定数组的大小。tx指针指向这个数组。
//下面实例告诉我们，不仅字符数组与字符指针有区别，用new给定内存空间大小的字符指针与没给定内存空间大小的字符指针也是有区别的 voidmain(){
/*char s[6]=”“;
strcpy(s,”abcd“);cout< /*char *s=new char[5];strcpy(s,”abcd“); } cout< char *s=”“;//分配了内存空间，但不知道大小 strcpy(s,”abcd“);//错误，使用时要注意！！cout< 3.指针 3.1指针可执行的运算 指针可以进行赋值运算、算术运算、关系运算。 1可以将与指针变量同类型的任一变量的地址赋给指针○2在C++中，可以（1）赋值运算：○ 3同类型的指针变量之间可以将0赋给任一指针变量，其含义是初始化指针变量，使其为空○相互赋值，不同类型的经强制转换后也可以，通常也没意义。（2）算术运算：指针变量执行“++”或“——”，其含义是使指针变量指向下一个或上一个元素 3.2指针和数组（同1.2）3.3指向数组的指针变量 char(*p)[10];(*p)指明p是一个指针变量，再与[10]结合，表示该指针变量所指向的数据是一个一维数组，该数组由10个元素组成。3.4指针数组 由若干个同类型的指针所组成的数组称为指针数组，数组的每个元素都是一个指针变量。定义指针数组的格式：如char *p[10];由于“[]”的优先级比“*”高，p[10]构成一个数组，再与“*”结合，指明是一个指针数组。3.5指向指针的指针变量 char **pp;3.6 new运算符 注意点： 用new运算符分配的内存空间的指针值必须保存起来，以便于delete运算符归还已动态分配的内存，否则会出现不可预测的错误。3.6.1指向数组的指针 char* m_p1;m_p1=new char[10];//指针m_p1指向含有10个元素的数组空间。for(i=0;i<10;i++)m_p2[i]表示这10个数组元素。 voidmain(){ char *p1;//char b;p1=newchar[5]; //p1=”abcde“;//直接给p1赋字符串，下面for循环中是给每个元素赋值。for(inti=0;i<5;i++){ //b='c'; } p1[i]='a';//p1[i]是数组元素，不是指针 cout< 3.6.2指向指针的指针变量 char**m_p2;//指向指针的指针 m_p2=new char*[10];//指针m_p2指向含有10个元素的指针数组。for(i=0;i<10;i++)m_p2[i]表示这10个指针。 void main(){ char *p1;char **pp;p1=new char[5];pp=new char*[5];for(int i=0;i<5;i++){ p1[i]='a';=&p1[i];//pp[i]是指针 cout< cout< 3.7 delete运算符 delete释放的不是指针本身，而是指针所指的对象。 4.容器类std::string #include int main(int argc, char * argv[]){ std::string str=”abc“; std::string::iterator cit=str.begin(); for(;cit!=NULL;++cit)//NULL比较，我估计肯定不对，虽然你说是可以通过编译 { std::cout<<*cit< } return 0;} 4.容器类Vector 4.1迭代器和指针的区别 有时需要使用指向vector的一个指针，我们可以这样来做。 vector 表达式v[0]生产一个指向vector中第一个元素的引用，所以，&v[0]是指向那个首元素的指针。vector中的元素被C++标准限定为存储在连续内存中，就像是一个数组。 如果你在一个不好的环境中，他们会告诉你说可以用v.begin()代替&v[0]，因为（这些讨厌的家伙将会告诉你）begin返回指向vector内部的迭代器，而对于vector，其迭代器实际上是指针。那经常是正确的，但正如条款50所说，并不总是如此，你不该依赖于此。 begin的返回类型是iterator，而不是一个指针，当你需要一个指向vector内部数据的指针时绝不该使用begin。如果你基于某些原因决定键入v.begin()，就应该键入&*v.begin()，因为这将会产生和&v[0]相同的指针。 这表明迭代器的内容*v.begin()才是vector中第一个元素。 4.2 容器vector的函数clear（） 清空vector里所有的元素。因此，如AMProcessList析构函数里一个个删除vector中所有的元素是多此一举。 5.关键字operator 它是说明符，用于重载运算符。 6.函数可以将一个处理的结果值通过函数的Return语句返回，也可以通过参数将处理的多个结果带给调用者。 C++语言在处理函数调用时，参数是自右向左依次入栈的 7.类的前置声明 8.Const char* Bjarne在他的The C++ Programming Language里面给出过一个助记的方法： 把一个声明从右向左读。 char * constcp;(* 读成 pointer to)cp is a const pointer to char--->cp是一个指向字符char的固定指针 const char * ptr;ptr is a pointer to const char;--->ptr是一个指向固定字符char的指针 char const * p;--->无此形式 也就是说,cp和ptr都是指针,cp的值是不可改变的cp指向的内容是可变的;而ptr的值是可以改变的,ptr指向的内容是不可变的 9.String转化为Constchar*,Const char*转化为char* 1.在string里面string.c_str()函数把string转换为了const char*.○代码如下： stringa=”abcd“;const char*p=a.c_str();2const_cast 10.初始化 char *p;char *s=”“;char *t=NULL;p没分配内存，s分配了内存，t为空，11.变量的初始化 1指针需要初始化； ○2基本数据类型声明的变量需要初始化；如double m_dvalue；m_dvalue=0； ○3类声明的对象不需要初始化。○ 12.派生类中的一般成员函数和虚函数 classA { public: voidsolid(){cout<<”基类实函数“<<'n';} virtualvoidvir(){cout<<”基类虚函数“<<'n';} };classAA:publicA { public: voidsolid(){cout<<”派生类实函数“<<'n';} virtualvoidvir(){cout<<”派生类虚函数“<<'n';} }; voidmain(){ A* a=newA;AA* aa=newAA;a=aa; a->vir();//vir()是虚函数。它是运行时的多态性，即在程序运行时，根据具体的执行情况来动态的确定。因此输出”派生类虚函数“，而不是“基类虚函数” a->solid();//solid()是一般成员函数。它是编译时的多态性，即程序编译时就觉得会调用哪个函数。因为a是A类对象的指针，即使派生类AA对象的指针aa赋给a，在编译是已经觉得调用基类A的solid函数，因此输出“基类虚函数”而不是“派生类虚函数” aa->vir();aa->solid(); aa->A::solid();aa->A::vir();} Button newBtn = new Button();newBtn.Location = new System.Drawing.Point(128, 110);newBtn.Name = ”newBtn“;newBtn.Size = new System.Drawing.Size(75, 23);newBtn.Text = ”button2";newBtn.UseVisualStyleBackColor = true;this.Controls.Add(newBtn); ///清除新生成的Btn this.Controls.Remove(newBtn); CButton* CTextEditorView::NewMyButton(int nID,CRect rect,int nStyle){ CString m_Caption;m_Caption.LoadString(nID);//取按钮标题 CButton *p_Button = new CButton();ASSERT_VALID(p_Button);p_Button->Create(m_Caption, WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | nStyle, rect, this, nID);//创建按钮 return p_Button;} 《编程知识总结》—C#难点总结 1.编写菜单中对应子菜单项的消息响应函数，考虑的方面很多，例 如，当前打开一个文件，此文件已经被修改，如果用户需要新建 或者打开另外一个文件，程序要询问用户是否保存当前的文件。 问题的解决：先用纸张写一份详细的业务流程图，在之后的编写 过程中，按照业务流程的规定进行功能的逐步实现。 2.编写判断是否要提醒用户保存的程序，判断是否提醒保存的根据 是什么。我的判断根据验证文件内容是否被修改，如果被修改，提醒用户保存。如果被保存的文件没有文件路径，调用另存为的 响应函数进行执行。 3.无法关闭窗体，当我响应文件菜单下退出菜单项的时候，如果使 用 Close()函数的话，可以就直接退出，但是当我需要以同样的 方式响应右上角关闭按钮的话，事件信息就会进入死循环，而且 永远不会结束。所以，在关闭窗体的时候，目前我用的就是 Application.exit()；这个函数，强制性终结这个窗口 4.保存文件，我们打开文件和直接输入信息的文件的情况，对于保 存来说是不一样的，因为打开的时候，应该是直接保存到指定的 文件中，而直接输入的应该提示保存，通过另存为的方式保存。5.文件的删除。C#的 textBox 没有直接为我们提供文本删除的函数，我弄了许久，后来，无意间突然发现通过已经选择的字符串的下 标来操作，就可以删除文件了，具体操作就是，先获取被选择文 件的前半部分，在获取后半部分，而略过中间被选中的部分即可。6.开始的时候没有使用 Using System.IO，系统报错； 7.由于在 MessageBox.Show 后没有写 return 导致错误； 8.初步创建简易记事本后点击打开文件选项并不显示文件的内容，且编译器报错了，是由于没有判断文件名为空，且文件的完整路 径名获取的不准确，将文件名为空的情况及其文件的完整路径名 获取之后，读取文件正确； 9.首先，我在添加单击“新建”响应的代码时，单击进去，结果代 码全部不能运行，必须是双击。 10.获取文件名时，文件名不需要特别处理，程序内部直接处理好的，我在这里画蛇添足了。 11.操作对象必须指代明确，不如要出错。 12.在用 WinForm 做文本文档的时候，在“新建文本文档”项的代码 中，需要在项目中新建一个 new 窗体作为“新建文本文档”，在 form1 的代码中写如下代码： Form frm = new NewForm();frm.Show();this.Hide();然后在 Form2 中下如同样的代码即可。 13.还发现“保存”与“另存为”项的代码编写没有任何差异，考虑 并修改程序无果。代码如下： private void 保存SToolStripMenuItem_Click(object sender, EventArgs e)// { DialogResult save = saveFileD ialog1.ShowDialog(); if (save == DialogResult.OK){ string filepath = saveFileDialog1.FileName;//FileInfo fi = new FileInfo(filepath);string content = richTextBox1.Text;File.WriteAllText(filepath, content, Encoding.Default);} } 14.在保存的时候必须输入保存路径才能正常执行，没有实现文本文 档的基本保存功能。并且在打开一个原本有内容的文本文档之后，加以修改再保存就不能保存新的内容。 15.获取 TextBox 中获取一行的值，使用 TextBox 的 Lines 属性来获 取 16.做删除操作时，由 MessageBoxv.show 来弹出一个确认窗体，把返 回的值赋给一个 DialogResult 类型的变量 17.在复制文件时，CopyTo 函数将第二个参数置为 TRUE 则在复制时，如果文件存在会被覆盖掉。 18.在向文件写入数据时，使用 Encoding 的 Default 的属性可避免输 入中文乱码问题。19.关于上午的文件编程，刚开始对程序要执行的具体操作不够明确，在编程时，功能实现的矛盾性问题很多，其问题在于编程前分析 不够到位； 20.文件编程中起先将打开文件定位为文件夹，导致弹出对话框显示 “不存在此文件”； 21.File.WriteAllLines（），无法将临时修改后的文件信息进行正 确保存，文本没有实现正确的回车换行；File.WriteAllText（）能实现； 22.this.Close()无法实现程序的结束 Close()方法是关闭 Form 23.当创建了控件的响应事件后，修改控件的 name 属性，响应事件 名为改变，但并不影响进程的进行，要修改方法名应删除该响应 方法，双击控件，重新获得响应事件。 24.代码经常会出现命名不规范的情况，同时没有写注释的习惯 25.经常会丢掉方法后的括号，如 savedialog1.showdialog()26.一 些 方 法 中 的 细 微 差 别 如 File.Write.AllLine 27.对于异常的处理经常忽略，导致程序的容错处理比较差。 28.当编辑框改变时有两种情况，一种是打开，一种是编辑，当打开 时不应该记录改变标志。解决的办法：做一个打开标志，当打开操作时，赋值为 true，在 文本框的改变函数中判断，如果是打开操作，将打开操作之位 false，同时文本改变标志值为 false 29.此处如何把长整形变量赋值给一个 string 类型？ 使用 ToString()30.如何在文本框上添加滚动条。设置 TextBox.ScrollBars 31.textbox 控件大小跟窗体一起变化：刚开始想通过相应窗体大小 改变事件的办法解决，后来通过其他同学得知可以通过更改 textbox 的 Dock 属性（改为 Fill）来解决。 32.当 textbox 空间的文本改变时，进行新建、打开、退出等操作时 应提示用户是否保存更改，通过设置文件更改标志（flag）并相 File.WriteAllText 和 响 textbox 的 textchanged 事件来解决。 33.由于需要提示用户保存更改，刚 开始时代码控制结构写的很复杂，连自己也有点难理解。后来用调用“保存”事件的响应函数（刚 开始一位不能这样）后才解决这一问题。 34.由于刚开始做，命名方面不是很规范，导致了变量、方法和类的 名字不易区分，不能一目了然，间接增加了编写程序所需的时间。解决方法是在编写程序中时刻遵守命名规范。 35.在对文件操作时，文件的路径经常出错，原因是少了转换为绝对 路径的@。 36.对文件注释太少，经常导致前面编过的代码过一段时间就完全看 不懂了，所以，在编程中也要养成随时加注释的习惯，其实这样 做表面上是增加了时间，统筹来看，这样做既方便了自己日后修 改程序，又为阅读我们程序的人提供了便利。 37.文件操作经常出错，程序无法运行，要因此要异常处理，比如说 用 try，catch 对异常处理。 38.在昨天上午的文件操作中，第一个问题就是路径的合法性检测。由于不知道 c#是否存在像 c++ access()一样的方法。最后使用 OpenFileDialog 来限定用户输入。可以使用正则表达式验证 39.再有就是文件操作异常处理。C#的异常处理还是很方便的，昨天 的经验是只要使用 try catch 语句，在 catch 中不作任何处理程 序也不会当掉。 40.MessageBox.Show(“你还没有保存上次的修改，是否保存修改？”, “保存”, MessageBoxButtons.YesNoCancel);选项的判断 问 同 学 得 ： 返 回 值 为 DialogResult.No DialogResult.Yes DialogResult.Cancel 41.2 ． private void Form1_FormClosing(object sender, FormClosingEventArgs e)中如何取消关闭 问同学得：e.Cancel = true;42.如何实现修改后 “新建”“打开”等提示保存 点打开保存后记 录存储路径 43.新建 2 个成员记录：private string Pathname;private bool savetxt=true; 44.如何在两个窗体间传递值。通过向同学和老师询问，知道传值有 很多种方法，我用的就是调用构造函数，可是老师也说了如果值 比较多的时候，这种方法还是有缺陷的。使用构造函数可以，只是也用对象会好一些。 45.当汉字改成英文时，函数中仍然是汉字，如果直接在 program.cs 中改容易出问题，怎么改？ 利用 VS 的代码重构 46.如何改窗体的默认主题样式 可以使用第三方控件完成 47.TextBox 中文本值改变时的响应事件（可以添加事件响应函数）。 48.文 件 打 开 中 将 文 件 写 到 textbox 中 ： 定 义 string[] 调 用 File.ReadAllLines 函数将文件内容逐行读入到字符串数组中，然后利用 for 循环将文件内容逐行写出到控件中。 49.填写邮箱和文件路径的时候需要有正确的规格，因为之前接触过 c#不知道该如何完成，后来在经过询问他人和网上资料查询得知 用正则表达式来规范正确 的格式，便避免了这方面因格式而导致 的问题。 50.当输入多行字符串，保存过后进行查看时，当有换行就会出现黑 乎乎的正方形。换行：rn 51.假设某个事件已经做好，可以作为一个模块使用，那么如何在其 他代码中调用此模块 52.记事本的查找、替换模块不知道如何实现 需要使用字符串函数 53.打开 txt 文件的时候中文没有乱码但是保持了之后在打开就有了 乱码 实现：原先是因为保持的时候没有使用 encoding.default 54.保存时文件不能自动保存文件 ？自动保存文件 55.在做简易记事本的途中，创建快捷键的时候遇到一点问题，当在 杂项的 Shortcutkeys 中选择 shift 的时候，它会报属性值无效的 错误，后来无奈之下选择了 Ctrl，居然就正确了 56.还有在 TextBox 的属性 Dock 选择了 fill 的时候，依然没有变成 全部填充，真是百思不得其解！需要将 TextBox 设置为多行文本 57.发现了一种比较简便的方法： 已经做完的某个控件出发的事件，可以作为一个法方来使用。例： private void SaveMenu_Click(object sender, EventArgs e){ //判断文件是否已有路径，若无，选定路径，若有,保存在最新操作的文件路径下 if(path == string.Empty){ if(SolgSave.ShowDialog()== DialogResult.OK){ path = SolgSave.FileName;File.AppendAllText(path, txtEdit.Text, Encoding.Default);} } else { File.AppendAllText(path, txtEdit.Text, Encoding.Default);} } private void ExitMenu_Click(object sender, EventArgs e){ if(txtEdit.Text!= string.Empty){ DialogResult dr = MessageBox.Show(“是否保存当前文本至 ”+path,“ 记 事 本 ”, MessageBoxButtons.OKCancel,MessageBoxIcon.Warning);if(dr == DialogResult.OK){ //使用保存文本方法 this.SaveMenu_Click(sender,e);//SaveMenu 的单击事件 } } //退出程序 Application.Exit();} 58.RichTextBox 与 TextBox 的换行区别问题。在 TextBox 中是以rn 为换行标志，而在 RichTextBox 中是以n 为换行标志。我在 C#程序中使用 RichTextBox 将其文本内容保存为文本文件，即（*.txt）类型的文件时，文本不能正常的换行，且出现一些乱码。这是由于文本文件是以rn 作为换行符，当我改用 TextBox 时，就 没有这样的问题了。 59.文本的选中问题。SelectedText 这一属性可以指向当前控件中选中的文本，60.通常我们会发现，保存操作在文本没有保存的情况下时才会出现 保存文件对话框，当文本已经保存过时，新增的文本会保存到原 文件中，这两个操作需要对文本是否保存过进行判断。我采用了 判断路径的方法对我文本是否保存过进行了判断，当文本路径存 在时，表明文本已经保存过，反之，则没有保存过。 宁波工程学院电信学院计算机教研室 实验报告 课程名称： Java 2 姓 名： *** 实验项目： 多线程实验 学 号： **** 指导教师： **** 班 级： **** 实验位置： 电信楼机房 日 期： 一、实验目的 1、掌握多线程编程的特点和工作原理； 2、掌握编写线程程序的方法 3、了解线程的调度和执行过程 4、掌握线程同步机理 二、实验环境 windows记事本，java jdk 1.60版本，cmd命令运行窗口 三、实验内容 实验一： 应用Java中线程的概念写一个Java程序（包括一个测试线程程序类TestThread，一个Thread类的子类PrintThread）。在测试程序中用子类PrintThread创建2个线程，使得其中一个线程运行时打印10次“线程1正在运行”，另一个线程运行时打印5次“线程2正在运行 源程序： public class A { public static void main(String args[]){ Test1 A1; Test2 A2; A1=new Test1(); A2=new Test2(); A1.start(); A2.start();} } class PrintThread extends Thread { } class Test1 extends PrintThread { public void run(){ for(int i=1;i<=10;i++) { System.out.println(“线程1正在运行！”); } } } class Test2 extends PrintThread { public void run(){ for(int i=1;i<=5;i++) { System.out.println(“线程2正在运行！”); } } } 运行结果： 实验二： 将上述程序用Runnable接口改写，并上机验证源程序 public class D { public static void main(String args[]){ Move move=new Move(); move.test1.start(); move.test2.start();} } class Move implements Runnable { Thread test1,test2;Move(){ test1=new Thread(this); test1.setName(“线程1正在运行！”); test2=new Thread(this); test2.setName(“线程2正在运行！”);} public void run(){ if(Thread.currentThread()==test1) { for(int i=1;i<=10;i++) { System.out.println(test1.getName()); } } } else { for(int i=1;i<=5;i++){ System.out.println(test2.getName());} } 运行结果： 实验三： import java.awt.*;import java.awt.event.*;public class E { public static void main(String args[]) { new FrameMoney(); } } class FrameMoney extends Frame implements Runnable,ActionListener { int money=100; TextArea text1,text2; Thread 会计,出纳; int weekDay; Button start=new Button(“开始演示”); FrameMoney() { 会计=new Thread(this); 出纳=new Thread(this); text1=new TextArea(12,15); text2=new TextArea(12,15); setLayout(new FlowLayout()); add(start); add(text1); add(text2); setVisible(true); setSize(360,300); validate(); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {System.exit(0); } }); start.addActionListener(this); } public void actionPerformed(ActionEvent e) { if(!(出纳.isAlive())) { 会计=new Thread(this); 出纳=new Thread(this); } try { 会计.start(); 出纳.start(); } catch(Exception exp){} } public synchronized void 存取(int number)//存取方法 { if(Thread.currentThread()==会计) { text1.append(“今天是星期”+weekDay+“n”); for(int i=1;i<=3;i++)//会计使用存取方法存入90元，存入30元，稍歇一下 { money=money+number; //这时出纳仍不能使用存取方法 try { Thread.sleep(1000);//因为会计还没使用完存取方法 } catch(InterruptedException e){} text1.append(“帐上有”+money+“万n”); } } else if(Thread.currentThread()==出纳) { text2.append(“今天是星期 ”+weekDay+“n”); for(int i=1;i<=2;i++)//出纳使用存取方法取出30元，取出15元，稍歇一下 { money=money-number/2; //这时会计仍不能使用存取方法 try { Thread.sleep(1000);//因为出纳还没使用完存取方法 } catch(InterruptedException e){} text2.append(“帐上有”+money+“万n”); } } } public void run() { if(Thread.currentThread()==会计||Thread.currentThread()==出纳) { for(int i=1;i<=3;i++)//从周一到周三会计和出纳都要使用帐本 { weekDay=i; 存取(30); } } } } 运行结果： } 四、实验心得与小结 通过本次实验，基本了解了线程的概念，作用，方法以及使用规则。1.首先：java 程序是建立在线程之上的。.2.创建线程必须继承 Thread class 它已经为线程的创建和运行做了必要的配置。run是线程就重要的方法。你必须覆写这个方法达到你想要的目的。3.run方法所包含的代码就是和其他线程同时运行的代码以达到同一时刻运行多段代码的目的。当终止了 run以后。这个线程也就结束了。调用线程的 start方法才会执行 run方法。 4.线程的生命周期：新建——Thread.State.NEW：当一个 Thread 类或者其子类的对象被声明并创建时，新的线程对象处于新建状态，此时它已经有了相应的内存空间和其他资源start方法尚未被调整用就绪可执行状态——Thread.State.RUNNABLE：处于新建状态的线程被启动后，将进入线程队列排队，这个时候具备了运行的条件，一旦轮到 CPU 的时候，就可以脱离创建它的主线程独立开始自己的生命周期运行：就绪的线程被调度进入运行状态，每一个 Thread 类及其子类的对象都有一个重要的run方法，当线程对象被调度执行的时候，它将自动调用本对象的 run方法，从第一句代码开始执行。第四篇：编程知识总结C难点总结
第五篇：多线程实验报告
点击咨询 