操作系统实验指导书2013原件

实验一熟悉Windows2000/XP中的进程和线程

一、实验目的

1、熟悉Windows2000/XP中任务管理器的使用。

2、通过任务管理器识别操作系统中的进程和线程的相关信息。

二、实验内容与步骤

1、启动操作系统自带的任务管理器：

方法：直接按组合键Ctrl+Alt+Del，或者是在点击任务条上的“开始”“运行”，并输入“taskmgr.exe”。如下图所示：

2、调整任务管理器的“查看”中的相关设置，显示关于进程的以下各项信息，

并完成下表（填满即可）：

表一：统计进程的各项主要信息

3、从桌面启动办公软件“Word”，在任务管理器中找到该软件的登记，并将其结

束掉。再从任务管理器中分别找到下列程序：winlogon.exe、csrss.exe，试着结束它们，观察到的反应是，原因是。

在任务管理器中找到进程“explorer.exe”，将之结束掉，并将桌面上你打开的所有窗口最小化，看看你的计算机系统起来什么样的变化、得到的结论是（说出explorer.exe进程的作用）。

实验二Windows编程＿GUI应用程序

一、实验目的

利用C++ 编译器创建一个GUI应用程序，代码中包括了WinMain() 方法，这是GUI类型的应用程序的标准入口点。

二、实验内容与步骤

步骤1：运行Visual C++ 6.0，在“文件”菜单中依次点击“新建”-“工

程”-“Win32 Application”命令，输入工程名，例如“1”，点击“确定”进入下一个对话框，选择“An simple Win32 Application”，点击“完成”按钮，将建立一个GUI 应用工程。

步骤2：在工作区点击“FileView”，双击“1.cpp”，将清单1中的程序键入1.cpp 中。注：有的代码已经由VC++自动生成，用户只要添加必要的代码即可。

// 1.cpp : Defines the entry point for the application.

#include "windows.h"

int APIENTRY WinMain(HINSTANCE hInstance,

HINSTANCE hPrevInstance,

LPSTR lpCmdLine,

int nCmdShow)

{

// TODO: Place code here.

::MessageBox(

NULL, // 没有父窗口

"Hello, Windows xp", // 消息框中的文本

"Greetings", // 消息框标题

MB_OK) ; // 其中只有一个OK按钮

// 返回0以便通知系统不进入消息循环

return 0;

}

关于1.cpp的一些说明：

/*///////////////////////////////////////////////////////////////////////////////////

APIENTRY: 表示是windows的mian函数的入口,实际上APIENTRY是个宏,其定义为

#define APIENTRY WINAPI

而WINAPI也是个宏,其定义为

#define WINAPI __stdcall

这是个关于调用时压栈顺序的修饰符,表示参数压栈的顺序

先压第一个参数，接下来是第二个，依此类推。

当然，定义回调函数也可以用APIENTRY

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

WinMain函数的定义

WinMain函数的原型声明如下：

int WINAPI WinMain(

HINSTANCE hInstance, // handle to current instance

HINSTANCE hPrevInstance, // handle to previous instance

LPSTR lpCmdLine, // command line

int nCmdShow // show state

);

WinMain函数接收4个参数，这些参数都是在系统调用WinMain函数时，传递给应用程序的。

第一个参数hInstance表示该程序当前运行的实例的句柄，这是一个数值。当程序在Windows下运行时，它唯一标识运行中的实例（注意，只有运行中的程序实例，才有实例句柄）。一个应用程序可以运行多个实例，每运行一个实例，系统都会给该实例分配一个句柄值，并通过hInstance参数传递给WinMain函数。第二个参数hPrevInstance表示当前实例的前一个实例的句柄。通过查看MSDN 我们可以知道，在Win32环境下，这个参数总是NULL，即在Win32环境下，这个参数不再起作用。

第三个参数lpCmdLine是一个以空终止的字符串，指定传递给应用程序的命令行参数。例如：在D盘下有一个sunxin.txt文件，当我们用鼠标双击这个文件时将启动记事本程序（notepad.exe），此时系统会将D:\sunxin.txt作为命令行参数传递给记事本程序的WinMain函数，记事本程序在得到这个文件的全路径名后，就在窗口中显示该文件的内容。要在VC++开发环境中向应用程序传递参数，可以单击菜单【Project】→【Settings】，选择“Debug”选项卡，在“Program arguments”编辑框中输入你想传递给应用程序的参数。

第四个参数nCmdShow指定程序的窗口应该如何显示，例如最大化、最小化、隐藏等。这个参数的值由该程序的调用者所指定，应用程序通常不需要去理会这个参数的值。

//LPSTR lpCmdLine lp前缀代表长指针。也可改为PSTR lpCmdLine，都是同一种类型，作为指向字符串的指针。

//另外前缀i 表示int，sz表示以零结束的字符串。

// #define WINAPI _stdcall 该语句指定一个约定，包括如何生成机器代码以及在堆栈中放置函数调用的参数，

//许多Windows函数调用声明为WINAPI

//HINSTANCE hInstance 实例句柄，该句柄唯一标识该程序。

//HINSTANCE hPrevInstance Windows早期版本中，同时运行同一程序多次时，您便创建了该程序的

// 多个实例。在32位Windows版本中，该概念已被抛弃。所以WinMain的第二个参数总是NULL（定义为0）

//LPSTR lpCmdLine 用于运行程序的命令行。某些Windows应用程序使用这个参数以在程序启动时将文件加载到内存。

//int nShowCmd 程序最初显示的方式。可以是正常地，或者是最大地，或者是最小化显示在任务列表栏中。

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

为了显示提示信息给用户，Windows是提供了一个非常方便的API函数MessageBox给用户使用，使用这个API函数可以显示简单的文字信息出来，提醒或提示用户进行下一步操作。

函数声明如下：

WINUSERAPI

int

WINAPI

MessageBoxA(

__in_opt HWND hWnd,

__in_opt LPCSTR lpText,

__in_opt LPCSTR lpCaption,

__in UINT uType);

WINUSERAPI

int

WINAPI

MessageBoxW(

__in_opt HWND hWnd,

__in_opt LPCWSTR lpText,

__in_opt LPCWSTR lpCaption,

__in UINT uType);

#ifdef UNICODE

#define MessageBox MessageBoxW

#else

#define MessageBox MessageBoxA

#endif // !UNICODE

从上面可以看出，Windows的API是两种声明，一种是使用到ANSI编码，一种是使用到UNICODE编码的API函数。通过宏定义把这两种API名称统一到MessageBox的声明。这是一种使用选择不同API的技术，在今后的编程里，大多数都需要使用UNICODE编码了，因为可以适应不同国家的语言显示，可以国际化编程，特别对于中文支持更加需要UNICODE编程。

下面来解释一下参数的定义：

hWnd是指向父窗口的句柄，如果没有父窗口，可以把这个参数设置为NULL。lpText是需要显示的文字。显示字符串的起始地址。

lpCaption是在窗口上标题显示。

uType是窗口组合按钮和显示图标的类型。后面再详细说明。

返回值是一个整数，如果有取消按钮，并且按下ESC键就返回IDCANCEL。如果有其它按钮，并且按下，

就返回相应的值。主要的值如下：

IDABORT 放弃按钮

IDCANCEL取消按钮

IDCONTINUE 继续按钮

IDIGNORE 忽略按钮

IDNO 否按钮

IDOK 确定按钮

IDRETRY 重试按钮

IDTRYAGAIN 重试按钮

IDYES 是按钮

步骤3：点击”Compile”和”Build”按钮，对工程文件进行编译连接，创建1.exe文件。如果不能顺利进行编译连接，可根据提示信息进行更正。

步骤4：点击Execute按钮，可运行程序1.exe。运行结果：弹出图形窗口，输出的字符串：“Hello, Windows xp”，窗口标题为“Greetings”，按“OK”键结束程序的运行。

思考：可通过编辑程序修改窗口属性。

实验三 Windows中进程的创建、运行和终止

一、实验目的

理解Windows中进程的创建、运行和终止。

二、实验内容及步骤

Windows所创建的每个进程都从调用CreateProcess() API函数开始，该函数的任务是在对象管理器子系统内初始化进程对象。每一进程都以调用ExitProcess() 或TerminateProcess() API函数终止。通常应用程序的框架负责调用ExitProcess() 函数。对于C++ 运行库来说，这一调用发生在应用程序的main() 函数返回之后。

1. 创建进程

CreateProcess() 调用的核心参数是可执行文件运行时的文件名及其命令行。表

1-1详细地列出了每个参数的类型和名称。

表3-1 CreateProcess() 函数的参数

可以指定第一个参数，即应用程序的名称，其中包括相对于当前进程的当前目录的全路径或者利用搜索方法找到的路径；lpCommandLine参数允许调用者向新应用程序发送数据；接下来的三个参数与进程和它的主线程以及返回的指向该对象的句柄的安全性有关。

然后是标志参数，用以在dwCreationFlags参数中指明系统应该给予新进程什么行为。经常使用的标志是CREATE_SUSPNDED，告诉主线程立刻暂停。当准备好时，应该使用ResumeThread() API来启动进程。另一个常用的标志是

CREATE_NEW_CONSOLE，告诉新进程启动自己的控制台窗口，而不是利用父窗口。这一参数还允许设置进程的优先级，用以向系统指明，相对于系统中所有其他的活动进程来说，给此进程多少CPU时间。

接着是CreateProcess() 函数调用所需要的三个通常使用缺省值的参数。第一个参数是lpEnvironment参数，指明为新进程提供的环境；第二个参数是lpCurrentDirectory，可用于向主创进程发送与缺省目录不同的新进程使用的特殊的当前目录；第三个参数是STARTUPINFO数据结构所必需的，用于在必要时指明新应用程序的主窗口的外观。

CreateProcess() 的最后一个参数是用于新进程对象及其主线程的句柄和ID的返回值缓冲区。以PROCESS_INFORMATION结构中返回的句柄调用CloseHandle() API 函数是重要的，因为如果不将这些句柄关闭的话，有可能危及主创进程终止之前

的任何未释放的资源。

2. 正在运行的进程

如果一个进程拥有至少一个执行线程，则为正在系统中运行的进程。通常，这种进程使用主线程来指示它的存在。当主线程结束时，调用ExitProcess() API函数，通知系统终止它所拥有的所有正在运行、准备运行或正在挂起的其他线程。当进程正在运行时，可以查看它的许多特性，其中少数特性也允许加以修改。

首先可查看的进程特性是系统进程标识符(PID) ，可利用GetCurrentProcessId() API函数来查看，与GetCurrentProcess() 相似，对该函数的调用不能失败，但返回的PID在整个系统中都可使用。其他的可显示当前进程信息的API函数还有GetStartupInfo()和GetProcessShutdownParameters() ，可给出进程存活期内的配置详情。

通常，一个进程需要它的运行期环境的信息。例如API函数GetModuleFileName() 和GetCommandLine() ，可以给出用在CreateProcess() 中的参数以启动应用程序。在创建应用程序时可使用的另一个API函数是IsDebuggerPresent() 。

可利用API函数GetGuiResources() 来查看进程的GUI资源。此函数既可返回指定进程中的打开的GUI对象的数目，也可返回指定进程中打开的USER对象的数目。进程的其他性能信息可通过GetProcessIoCounters()、GetProcessPriorityBoost() 、GetProcessTimes() 和GetProcessWorkingSetSize() API 得到。以上这几个API函数都只需要具有PROCESS_QUERY_INFORMATION访问权限的指向所感兴趣进程的句柄。

另一个可用于进程信息查询的API函数是GetProcessVersion() 。此函数只需感兴趣进程的PID (进程标识号) 。本实验程序清单3中列出了这一API函数与GetVersionEx() 的共同作用，可确定运行进程的系统的版本号。

3. 终止进程

所有进程都是以调用ExitProcess() 或者TerminateProcess() 函数结束的。但最好使用前者而不要使用后者，因为进程是在完成了它的所有的关闭“职责”之后以正常的终止方式来调用前者的。而外部进程通常调用后者即突然终止进程的进行，由于关闭时的途径不太正常，有可能引起错误的行为。

TerminateProcess() API函数只要打开带有PROCESS_TERMINATE访问权的进程对象，就可以终止进程，并向系统返回指定的代码。这是一种“野蛮”的终止进程的方式，但是有时却是需要的。

如果开发人员确实有机会来设计“谋杀”(终止别的进程的进程) 和“受害”进程(被终止的进程) 时，应该创建一个进程间通讯的内核对象——如一个互斥程序——这样一来，“受害”进程只在等待或周期性地测试它是否应该终止。

1. 创建进程

本实验显示了创建子进程的基本框架。该程序只是再一次地启动自身，显示它的

系统进程ID和它在进程列表中的位置。

步骤1：运行Visual C++ 6.0

步骤2：“文件”->“新建”->“C++ Source File”，建立源程序3-1.cpp。

清单3-1 创建子进程

// proccreate项目

# include

# include

# include

// 创建传递过来的进程的克隆过程并赋于其ID值

void StartClone(int nCloneID)

{

// 提取用于当前可执行文件的文件名

TCHAR szFilename[MAX_PATH] ;

:: GetModuleFileName(NULL, szFilename, MAX_PATH) ;

// 格式化用于子进程的命令行并通知其EXE文件名和克隆ID

TCHAR szCmdLine[MAX_PATH] ;

:: sprintf(szCmdLine, “\”%s\” %d”, szFilename, nCloneID) ;

// 用于子进程的STARTUPINFO结构

STARTUPINFO si;

:: ZeroMemory(reinterpret_cast (&si) , sizeof(si) ) ;

si.cb = sizeof(si) ; // 必须是本结构的大小

// 返回的用于子进程的进程信息

PROCESS_INFORMATION pi;

// 利用同样的可执行文件和命令行创建进程，并赋于其子进程的性质BOOL bCreateOK = :: CreateProcess(

szFilename, // 产生这个EXE的应用程序的名称 szCmdLine, // 告诉其行为像一个子进程的标志NULL, // 缺省的进程安全性

NULL, // 缺省的线程安全性

FALSE, // 不继承句柄

CREATE_NEW_CONSOLE, // 使用新的控制台

NULL, // 新的环境

NULL, // 当前目录

&si, // 启动信息

&pi) ; // 返回的进程信息

// 对子进程释放引用

if (bCreateOK)

{

:: CloseHandle(pi.hProcess) ;

:: CloseHandle(pi.hThread) ;

}

}

int main(int argc, char* argv[] )

{

// 确定进程在列表中的位置

int nClone(0) ;

if (argc > 1)

{

// 从第二个参数中提取克隆ID

:: sscanf(argv*1+ , “%d” , &nClone) ;

}

// 显示进程位置

std :: cout << “Process ID: “ << :: GetCurrentProcessId()

<< “, Clone ID: “ << nClone

<< std :: endl;

// 检查是否有创建子进程的需要

const int c_nCloneMax = 25;

if (nClone < C_nCloneMax)

{

// 发送新进程的命令行和克隆号

StartClone(++nClone) ;

}

// 在终止之前暂停一下(l/2秒)

:: Sleep(500) ;

return 0;

}

步骤3：点击”Compile”和”Build”按钮，对工程文件进行编译连接，创建3-1.exe 文件。如果不能顺利进行编译连接，可根据提示信息进行更正。

步骤4：点击Execute按钮，可运行程序3-1.exe。

步骤5：按Ctrl + S键可暂停程序的执行，按Ctrl + Pause (Break) 键可终止程序的执行。

2. 正在运行的进程

本实验的程序中列出了用于进程信息查询的API函数GetProcessVersion() 与GetVersionEx() 的共同作用，可确定运行进程的操作系统的版本号。

步骤6：建立源程序3-2.cpp。

清单3-2 使用进程和操作系统的版本信息

// version项目

# include

# include

// 利用进程和操作系统的版本信息的简单示例

void main()

{

// 提取这个进程的ID号

DWORD dwIdThis = :: GetCurrentProcessId() ;

// 获得这一进程和报告所需的版本，也可以发送0以便指明这一进程

DWORD dwVerReq = :: GetProcessVersion(dwIdThis) ;

WORD wMajorReq = (WORD) dwVerReq > 16) ;

WORD wMinorReq = (WORD) dwVerReq & 0xffff) ;

std :: cout << “Process ID: “ << dwIdThis

<< “, requires OS: “ << wMajorReq << wMinorReq << std :: endl ;

// 设置版本信息的数据结构，以便保存操作系统的版本信息

OSVERSIONINFOEX osvix;

:: ZeroMemory(&osvix, sizeof(osvix) ) ;

osvix.dwOSVersionInfoSize = sizeof(osvix) ;

// 提取版本信息和报告

:: GetVersionEx(reinterpret_cast < LPOSVERSIONINFO > (&osvix) ) ;

std :: cout << “Running on OS: “ << osvix.dwMajorVersion << “.”

<< osvix.dwMinorVersion << std :: endl;

// 如果是NTS (Windows 2000) 系统，则提高其优先权

/* if (osvix.dwPlatformld = = VER_PLATFORM_WIN32_NT &&

osvix.dwMajorVersion >= 5)

{

// 改变优先级

:: SetPriorityClass(

:: GetCurrentProcess() , // 利用这一进程

HIGH_PRIORITY_CLASS) ; // 改变为high

// 报告给用户

std :: cout << “Task Manager should now now indicate this”

“process is high priority．” << std :: endl;

}*/

}

步骤7：点击”Compile”和”Build”按钮，对工程文件进行编译连接，创建3-2.exe 文件。如果不能顺利进行编译连接，可根据提示信息进行更正。

步骤8：点击Execute按钮，可运行程序3-2.exe。

除了改变进程的优先级以外，还可以对正在运行的进程执行几项其他的操作，只要获得其进程句柄即可。SetProcessAffinityMask() API函数允许开发人员将线程映射到处理器上；SetProcessPriorityBoost() API可关闭前台应用程序优先级的提升；而SetProcessWorkingSet() API可调节进程可用的非页面RAM的容量；还有一个只对当前进程可用的API函数，即SetProcessShutdownParameters() ，可告诉系统如何终止该进程。

3. 终止进程

在清单3-3列出的程序中，先创建一个子进程，然后指令它发出“自杀弹”互斥体去终止自身的运行。

步骤9：建立源程序3-3.cpp。

清单3-3 指令其子进程来“杀掉”自己的父进程

// procterm项目

# include

# include

# include

static LPCTSTR g_szMutexName = “w2kdg.ProcTerm.mutex.Suicide” ;

// 创建当前进程的克隆进程的简单方法

void StartClone()

{

// 提取当前可执行文件的文件名

TCHAR szFilename [MAX_PATH] ;

:: GetModuleFileName(NULL, szFilename, MAX_PATH) ;

// 格式化用于子进程的命令行，指明它是一个EXE文件和子进程

TCHAR szCmdLine[MAX_PATH] ;

:: sprintf(szCmdLine, “\” %s\ “ child” , szFilename) ;

// 子进程的启动信息结构

STARTUPINFO si;

:: ZeroMemory(reinterpret_cast < void* > (&si) , sizeof(si) ) ;

si.cb = sizeof(si) ; // 应当是此结构的大小

// 返回的用于子进程的进程信息

PROCESS_INFORMATION pi;

// 用同样的可执行文件名和命令行创建进程，并指明它是一个子进程

BOOL bCreateOK = :: CreateProcess(

szFilename, // 产生的应用程序名称(本EXE文件)

szCmdLine, // 告诉我们这是一个子进程的标志NULL, // 用于进程的缺省的安全性

NULL, // 用于线程的缺省安全性

FALSE, // 不继承句柄

CREATE_NEW_CONSOLE, // 创建新窗口，使输出更直观

NULL, // 新环境

NULL, // 当前目录

&si, // 启动信息结构

&pi ) ; // 返回的进程信息

// 释放指向子进程的引用

if (bCreateOK)

{

:: CloseHandle(pi.hProcess) ;

:: CloseHandle(pi.hThread) ;

}

}

void Parent()

{

// 创建“自杀”互斥程序体

HANDLE hMutexSuicide = :: CreateMutex(

NULL, // 缺省的安全性

TRUE, // 最初拥有的

g_szMutexName) ; // 为其命名

if (hMutexSuicide != NULL)

{

// 创建子进程

std :: cout << “Creating the child process.” << std :: endl;

:: StartClone() ;

// 暂停

:: sleep(5000) ;

// 指令子进程“杀”掉自身

std :: cout << “Telling the child process to quit. ” << std :: endl;

:: ReleaseMutex(hMutexSuicide) ;

// 消除句柄

:: CloseHandle(hMutexSuicide) ;

}

}

void Child()

{

// 打开“自杀”互斥体

HANDLE hMutexSuicide = :: OpenMutex(

SYNCHRONIZE, // 打开用于同步

FALSE, // 不需要向下传递

g_szMutexName) ; // 名称

if (hMutexSuicide != NULL)

{

// 报告正在等待指令

std :: cout << “Child waiting for suicide instructions. ” << std :: endl;

:: WaitForSingleObject(hMutexSuicide, INFINITE) ;

// 准备好终止，清除句柄

std :: cout << “Child quiting. ” << std :: endl;

:: CloseHandle(hMutexSuicide) ;

}

}

int main(int arqc, char* argv[] )

{

// 决定其行为是父进程还是子进程

if (argc > l && :: strcmp(ar gv*l+ , “child” ) = = 0)

{

Child() ;

}

else

{

Parent() ;

}

return 0;

}

清单3-3中的程序说明了一个进程从“生”到“死”的整个一生。第一次执行时，它创建一个子进程，其行为如同“父亲”。在创建子进程之前，先创建一个互斥的内核对象，其行为对于子进程来说，如同一个“自杀弹”。当创建子进程时，就打开了互斥体并在其他线程中进行别的处理工作，同时等待着父进程使用ReleaseMutex() API发出“死亡”信号。然后用Sleep() API调用来模拟父进程处理其他工作，等完成时，指令子进程终止。

当调用ExitProcess() 时要小心，进程中的所有线程都被立刻通知停止。在设计应用程序时，必须让主线程在正常的C++ 运行期关闭(这是由编译器提供的缺省行为) 之后来调用这一函数。当它转向受信状态时，通常可创建一个每个活动线程都可等待和停止的终止事件。

在正常的终止操作中，进程的每个工作线程都要终止，由主线程调用ExitProcess()。接着，管理层对进程增加的所有对象释放引用，并将用GetExitCodeProcess() 建立的退出代码从STILL_ACTIVE改变为在ExitProcess() 调用中返回的值。最后，主线程对象也如同进程对象一样转变为受信状态。

等到所有打开的句柄都关闭之后，管理层的对象管理器才销毁进程对象本身。还没有一种函数可取得终止后的进程对象为其参数，从而使其“复活”。当进程对象引用一个终止了的对象时，有好几个API函数仍然是有用的。进程可使用退出代码将终止方式通知给调用GetExitCodeProcess() 的其他进程。同时，GetProcessTimes() API函数可向主调者显示进程的终止时间。

步骤10：点击”Compile”和”Build”按钮，对工程文件进行编译连接，创建3-3.exe 文件。如果不能顺利进行编译连接，可根据提示信息进行更正。

步骤11：点击Execute按钮，可运行程序3-3.exe。

实验四进程同步-生产者/消费者问题

一、实验目的

掌握临界区的概念及临界区的设计原则；掌握信号量的概念、PV操作的含义以及应用PV操作实现进程的同步与互斥；分析进程争用资源的现象，学习解决进程互斥的方法。

二、实验内容及步骤

1、生产者和消费者原理分析

在同一个进程地址空间内执行的两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品，然后释放缓冲区。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。

2、生产者与消费者功能描述

1）生产者功能描述

在同一个进程地址空间内执行的两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。

2）消费者功能描述

消费者线程从缓冲区中获得物品，然后释放缓冲区。当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。

3）程序结构图

3、数据结构及信号量定义说明

(1) CreateThread

●功能——创建一个在调用进程的地址空间中执行的线程

●格式

HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes,

DWORD dwStackSize,

LPTHREAD_START_ROUTINE lpStartAddress,

LPVOID lpParamiter,

DWORD dwCreationFlags,

Lpdword lpThread );

●参数说明

lpThreadAttributes——指向一个LPSECURITY_ATTRIBUTES(新线程的安全性描述符)。

dwStackSize——定义原始堆栈大小。

lpStartAddress——指向使用LPTHRAED_START_ROUTINE类型定义的函数。lpParamiter——定义一个给进程传递参数的指针。dwCreationFlags——定义控制线程创建的附加标志。

lpThread——保存线程标志符(32位)

(2) CreateMutex

●功能——创建一个命名或匿名的互斥量对象

●格式

HANDLE CreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes,

BOOL bInitialOwner,

LPCTSTR lpName);

●参数说明

lpMutexAttributes——必须取值NULL。

bInitialOwner——指示当前线程是否马上拥有该互斥量(即马上加锁)。lpName——互斥量名称。

(3) CreateSemaphore

●功能——创建一个命名或匿名的信号量对象

●格式

HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,

LONG lInitialCount,

LONG lMaximumCount,

LPCTSTR lpName );

●参数说明

lpSemaphoreAttributes——必须取值NULL。

lInitialCount——信号量的初始值。该值大于0，但小于lMaximumCount指定的最大值。

lMaximumCount——信号量的最大值。

lpName——信号量名称。

(4) WaitForSingleObject

●功能——使程序处于等待状态，直到信号量hHandle出现(即其值大于等于1)或超过规定的等待时间

●格式

DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);

●参数说明

hHandle——信号量指针。

dwMilliseconds——等待的最长时间(INFINITE为无限等待)。

(5) ReleaseSemaphore

●功能——对指定信号量加上一个指定大小的量。成功执行则返回非0值

●格式

BOOL ReleaseSemaphore(HANDLE hSemaphore,

LONG lReleaseCount,

LPLONG lppreviousCount );

●参数说明

hSemaphore——信号量指针。

lReleaseCount——信号量的增量。

lppreviousCount——保存信号量当前值。

(6) ReleaseMutex

●功能——打开互斥锁，即把互斥量加1。成功调用则返回0

●格式

BOOL ReleaseMutex(HANDLE hMutex);

●参数说明

hMutex——互斥量指针。

(7) InitializeCriticalSection

●功能——初始化临界区对象

●格式

VOID InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

●参数说明

lpCriticalSection——指向临界区对象的指针。

(8) EnterCriticalSection

●功能——等待指定临界区对象的所有权

●格式

VOID enterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

●参数说明

lpCriticalSection——指向临界区对象的指针。

(9) LeaveCriticalSection

●功能——释放指定临界区对象的所有权

●格式

VOID LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

●参数说明

lpCriticalSection——指向临界区对象的指针。

4、实验步骤

(1) 打开VC，选择菜单项file->new,选择projects选项卡并建立一个名为" 4"的win32 console applicatoin工程；创建时注意指定创建该工程的目录；

(2) 在工程中创建源文件" 4.cpp"，加入工程。

（3）编译，连接，运行。

5、生产者与消费者实现代码

#include

#include

const unsigned short SIZE_OF_BUFFER = 10; //缓冲区长度

unsigned short ProductID = 0; //产品号

unsigned short ConsumeID = 0; //将被消耗的产品号

unsigned short in = 0; //产品进缓冲区时的缓冲区下标

unsigned short out = 0; //产品出缓冲区时的缓冲区下标

int g_buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列

bool g_continue = true; //控制程序结束

HANDLE g_hMutex; //用于线程间的互斥

HANDLE g_hFullSemaphore; //当缓冲区满时迫使生产者等待

HANDLE g_hEmptySemaphore; //当缓冲区空时迫使消费者等待

DWORD WINAPI Producer(LPVOID); //生产者线程

DWORD WINAPI Consumer(LPVOID); //消费者线程

int main()

{

//创建各个互斥信号

g_hMutex = CreateMutex(NULL,FALSE,NULL);

g_hFullSemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER-1,SIZE_OF_BUFFER-1,NULL);

g_hEmptySemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL);

//调整下面的数值，可以发现，当生产者个数多于消费者个数时，

//生产速度快，生产者经常等待消费者；反之，消费者经常等待

const unsigned short PRODUCERS_COUNT = 3; //生产者的个数

const unsigned short CONSUMERS_COUNT = 1; //消费者的个数

//总的线程数

const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT;

HANDLE hThreads[PRODUCERS_COUNT]; //各线程的handle

DWORD producerID[CONSUMERS_COUNT]; //生产者线程的标识符

DWORD consumerID[THREADS_COUNT]; //消费者线程的标识符

//创建生产者线程

for (int i=0;i

hThreads[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);

if (hThreads[i]==NULL) return -1;

}

//创建消费者线程

for (i=0;i

hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&consum erID[i]);

if (hThreads[i]==NULL) return -1;

}

while(g_continue){

if(getchar()){ //按回车后终止程序运行

g_continue = false;

}

}

return 0;

}

//生产一个产品。简单模拟了一下，仅输出新产品的ID号

void Produce()

{

std::cerr << "Producing " << ++ProductID << " ... ";

std::cerr << "Succeed" << std::endl;

}

//把新生产的产品放入缓冲区

void Append()

{

std::cerr << "Appending a product ... ";

g_buffer[in] = ProductID;

in = (in+1)%SIZE_OF_BUFFER;

std::cerr << "Succeed" << std::endl;

//输出缓冲区当前的状态

for (int i=0;i

std::cout << i <<": " << g_buffer[i];

if (i==in) std::cout << " <-- 生产";

if (i==out) std::cout << " <-- 消费";

std::cout << std::endl;

}

}

//从缓冲区中取出一个产品

void Take()