当前位置：文档之家 › 操作系统实验线程的同步

操作系统实验线程的同步

  • 格式：doc
  • 大小：243.50 KB
  • 文档页数：12

操作系统实验线程的同步部门： xxx时间： xxx整理范文，仅供参考，可下载自行编辑实验六线程的同步1、实验目的（1）进一步掌握Windows系统环境下线程的创建与撤销。

（2）熟悉Windows系统提供的线程同步API。

（3）使用Windows系统提供的线程同步API解决实际问题。

2、实验准备知识：相关API函数介绍①等待对象等待对象<wait functions）函数包括等待一个对象<WaitForSingleObject<））和等待多个对象<WaitForMultipleObject<））两个API函数。

b5E2RGbCAP1）等待一个对象WaitForSingleObject<）用于等待一个对象。

它等待的对象可以为以下对象之一。

·Change ontification:变化通知。

·Console input: 控制台输入。

·Event:事件。

·Job:作业。

·Mutex:互斥信号量。

·Process:进程。

·Semaphore:计数信号量。

·Thread:线程。

·Waitable timer:定时器。

原型：DWORD WaitForSingleObject(HANDLE hHandle, // 对象句柄DWORD dwMilliseconds // 等待时间）；参数说明：（1）hHandle:等待对象的对象句柄。

该对象句柄必须为SYNCHRONIZE访问。

dwMilliseconds:等待时间，单位为ms。

若该值为0，函数在测试对象的状态后立即返回，若为INFINITE，函数一直等待下去，直到接收到一个信号将其唤醒，如表2-1所示。

p1EanqFDPw返回值：如果成功返回，其返回值说明是何种事件导致函数返回。

表2-1 函数描述用法举例：Static HANDLE hHandlel = NULL。

DWORD dRes。

dRes = WaitForSingleObject(hHandlel,10>。

//等待对象的句柄为hHandlel，等待时间为10msDXDiTa9E3d2）等待对个对象WaitForMultiple<）bject<）在指定时间内等待多个对象，它等待的对象与WaitForSingleObject<）相同。

RTCrpUDGiT原型：DWORD WaitForMultipleObjects<DWORD nCount， //句柄数组中的句柄数CONST HANDLE * lpHandles， //指向对象句柄数组的指针BOOL fWaitAll， //等待类型DWORD dwMilliseconds //等待时间）；参数说明：nCount：由指针 * lpHandles指定的句柄数组中的句柄数，最大数是MAXIMUM WAIT OBJECTS。

5PCzVD7HxA（2）* lpHandles：指向对象句柄数组的指针。

fWaitAll：等待类型。

若为TRUE，当由lpHandles数组指定的所有对象被唤醒时函数返回；若为FALSE，当由lpHandles数组指定的某一个对象被唤醒时函数返回，且由返回值说明是由于哪个对象引起的函数返回。

jLBHrnAILgdwMilliseconds：等待时间，单位为ms。

若该值为0，函数测试对象的状态后立即返回；若为INFINITE，函数一直等待下去，直到接收到一个信号将其唤醒。

xHAQX74J0X返回值：、如果成功返回，其返回值说明是何种事件导致函数返回。

各参数的描述如表2-2所示。

表2-2 各参数描述②信号量对象<Semaphore）信号量对象<Semaphore）包括创建信号量<CreateSemaphore<））、打开信号量<OpenSemaphore<））及增加信号量的值<ReleaseSemaphore<））API函数。

LDAYtRyKfE1）创建信号量CreateSemaphore<））用于创建一个信号量。

原型：HANDLE CreateSemaphore(LPSECURITY ATTRIBUTES lpSemaphoreAttributes, //安全属性Zzz6ZB2LtkLONG lInitialCount， //信号量对象的初始值dvzfvkwMI1LONG lMaximumCount， //信号量的最大值rqyn14ZNXILPCTSTR lpName //信号量名EmxvxOtOco）；参数说明：<1）lpSemaphoreAttributes：指定安全属性，为NULL时，信号量得到一个默认的安全描述符。

lInitialCount：指定信号量对象的初始值。

该值必须大于等于0，小于等于lMaximumCount。

当其值大于0时，信号量被唤醒。

当该函数释放了一个等待该信号量的线程时，lInitialCount值减1，当调用函数ReleaseSemaphore<）时，按其指定的数量加一个值。

SixE2yXPq5（3）lMaximumCount：指出该信号量的最大值，该值必须大于0。

（4）lpName：给出信号量的名字。

返回值：信号量创建成功，将返回该信号量的句柄。

如果给出的信号量名是系统已经存在的信号量，将返回这个已存在信号量的句柄。

如果失败，系统返回NULL，可以调用函数GetLastError<）查询失败的原因。

6ewMyirQFL用法举例：Static HANDLE hHandlel= NULL； //定义一个句柄//创建一个信号量，其初始值为0，最大值为5，信号量的名字为“SemphoreNamel”HHandle=CreateSemaphore<NULL，0，5，“SemphoreNamel”）；2）打开信号量OpenSemaphore<）用于打开一个信号量。

原型：HANDLE OpenSemaphore<DWORD dWDesiredAccess， //访问标志BOOL bInheritHandle， //继承标志LPCTSTR lpName //信号量名）；参数说明：（1）dwDesiredAccess：指出打开后要对信号量进行何种访问，如表2-3所示。

表2-3 访问状态<2）bInheritHandle：指出返回的信号量句柄是否可以继承。

<3）lpName：给出信号量的名字。

返回值：信号量打开成功，将返回该号量的句柄；如果失败，系统返回NULL，可以调用函数GetLastError<）查询失败的原因。

kavU42VRUs用法举例：static HANDLE hHandlel= NULL ；//打开一个名为“SemphoreNamel”的信号量，之后可使用ReleaseSemaphore<）函数增加信号量的值hHandlel= OpenSemaphore<SEMAPHORE MODIFY STATE，NULL，“SemphoreNamel”）；y6v3ALoS893）增加信号量的值ReleaseSemaphore<）用于增加信号量的值。

原型：BOOL ReleaseSemaphore<HANDLE hSemaphore， //信号量对象句柄LONG lReleaseCount， //信号量要增加数值LPLONG lpPreviousCount //信号量要增加数值的地址）；参数说明：hSemaphore：创建或打开信号量时给出的信号量对象句柄。

Windows NT中建议要使用SEMAPHOREMODIFY STATE访问属性打开该信号量。

M2ub6vSTnPIReleaseCount：信号量要增加的数值。

该值必须大于0。

如果增加该值后，大于信号量创建时给出的lMaximumCount值，则增加操作失效，函数返回FALSE。

0YujCfmUCwLpPreviousCounte：接收信号量值的一个32位的变量。

若不需要接收该值，可以指定为NULL。

eUts8ZQVRd返回值：如果成功，将返回一个非0值；如果失败，系统返回0，可以调用函数GetLastError<）查询失败的原因。

sQsAEJkW5T用法举例：static HANDLE hHandlel= NULL。

BOOL rc。

Rc= ReleaseSemaphore(hHandlel,l,NULL>。

//给信号量的值加13、实验内容完成主、子两个线程之间的同步，要求子线程先执行。

在主线程中使用系统调用GreateThread<）创建一个子线程。

主线程创建子线程后进入阻塞状态，直到子线程运行完毕后唤醒主线程。

GMsIasNXkA4、实验要求能正确使用等待对象WaitForSingleObject<）或WaitForMultipleObject<）及信号量对象CreateSemaphore<）、OpenSemaphore<）、ReleaseSemaphore<）等系统调用，进一步理解线程的同步。

TIrRGchYzg5、实验指导具体操作过程：在Microsoft Visual C++ 6.0环境下建立一个MFC支持的控制台工程文件，编写C程序，在程序中使用CreateSemaphore<NULL，0，1，“SemaphoreNamel”）创建一个名为“SemaphoreNamel”的信号量，信号量的初始值为0，之后使用0penSemaphore<SYNCHRONIZE|SEMAPHOSE MODIFY STATE，NULL，“SemaphoreNamel”）打开该信号量，这里访问标志用“SYNCHRONIZE|SEMAPHORE MODIFY STATE”，以便之后可以使用WaitForSingleObject(>等待该信号量及使用ReleaseSemaphore<）释放该信号量，然后创建一个子线程，主线程创建子线程后调用WaitForSingleObject<hHandlel，INFINITE），这里等待时间设置为INFINITE表示要一直等待下去，直到该信号量被唤醒为止。

子线程结束，调用ReleaseSemaphore<hHandlel，1，NULL）释放信号量，使信号量的值加1。

7EqZcWLZNX6、实验总结该实验完成了主、子线程的同步，主线程创建子线程后，主线程阻塞，让子线程先执行，等子线程执行完毕后，由子线程唤醒主线程。

lzq7IGf02E7、实验展望上面的程序完成了主、子两个线程执行先后顺序的同步关系，思考以下问题。

合集下载

操作系统实验二

操作系统实验二

实验二并发与调度一、实验目的在本实验中，通过对事件和互斥体对象的了解，来加深对Windows 2000线程同步的理解。

通过分析实验程序，了解管理事件对象的API。

了解在进程中如何使用事件对象，在进程中如何使用互斥体对象，线程如何通过文件映射对象发送数据。

在Linux Redhat 9.0操作系统平台上，用pipe()创建一个管道文件，然后用fork()创建两个生产进程和两个消费进程，它们之间通过pipe()传递消息。

二、实验环境硬件环境：计算机一台，局域网环境；软件环境：Windows 2000 Professional，Linux Redhat 9.0操作系统平台，Visual C++ 6.0企业版。

三、实验内容和步骤第一部分：互斥体对象本程序中显示的类CCountUpDown使用了一个互斥体来保证对两个线程间单一数值的访问。

每个线程都企图获得控制权来改变该数值，然后将该数值写入输出流中。

创建者实际上创建的是互斥体对象，计数方法执行等待并释放，为的是共同使用互斥体所需的资源(因而也就是共享资源) 。

利用互斥体保护共享资源// mutex项目# include <windows.h># include <iostream>class CCountUpDown{public:CCountUpDown(int nAccesses) :m_hThreadInc(INV ALID_HANDLE_V ALUE) ,m_hThreadDec(INV ALID_HANDLE_V ALUE) ,m_hMutexV alue(IN V ALID_HANDLE_V ALUE) ,m_nV alue(0) ,m_nAccess(nAccesses){m_hMutexV alue = :: CreateMutex(NULL,TRUE,NULL) ;m_hThreadInc = :: CreateThread(NULL,0,IncThreadProc,reinterpret_cast <LPVOID> (this) ,0,NULL) ;m_hThreadDec = :: CreateThread(NULL,0,DecThreadProc,reinterpret_cast <LPVOID> (this) ,0,NULL) ;:: ReleaseMutex(m_hMutexV alue) ;}virtual ~CCountUpDown(){:: CloseHandle(m_hThreadInc) ;:: CloseHandle(m_hThreadDec) ;:: CloseHandle(m_hMutexV alue) ;}virtual void WaitForCompletion(){if (m_hThreadInc != INV ALID_HANDLE_V ALUE &&m_hThreadDec != INV ALID_HANDLE_V ALUE){:: WaitForSingleObject(m_hThreadInc, INFINITE) ;:: WaitForSingleObject(m_hThreadDec, INFINITE) ;}}protected:virtual void DoCount(int nStep){while (m_nAccess > 0){:: WaitForSingleObject(m_hMutexV alue, INFINITE) ;m_nV alue += nStep;std :: cout << “thread: ” << :: GetCurrentThreadId()<< “value: ” << m_n V alue<< “access: ” << m_nAccess << std :: endl;--m_nAccess;:: Sleep(1000) ; // 使显示速度放慢:: ReleaseMutex(m_hMutexV alue) ;}}static DWORD WINAPI IncThreadProc(LPVOID lpParam){CCountUpDown* pThis =reinterpret_cast < CCountUpDown* > (lpParam) ;pThis -> DoCount(+1) ;return(0) ;}static DWORD WINAPI DecThreadProc(LPVOID lpParam){CCountUpDown* pThis =reinterpret_cast <CCountUpDown* > (lpParam) ;pThis -> DoCount(-1) ;return(0) ;}protected:HANDLE m_hThreadInc;HANDLE m_hThreadDec;HANDLE m_hMutexV alue;int m_nV alue;int m_nAccess ;} ;void main(){ CCountUpDown ud(50) ;ud.WaitForCompletion() ; }分析程序的运行结果，可以看到线程(加和减线程) 的交替执行(因为Sleep() API允许Windows切换线程) 。

进程的同步与互斥实验报告

进程的同步与互斥实验报告

进程的同步与互斥实验报告1.实验目的进程（线程）的同步与互斥是操作系统中非常重要的概念，本实验旨在通过实际操作，加深对这些概念的理解和掌握。

通过编写多个进程（线程），并在其间进行同步与互斥操作，验证同步与互斥的实际效果。

2.实验环境本实验在Linux系统下进行，使用C/C++语言编程。

3.实验内容3.1同步在实验中，我们编写了两个进程A和B，这两个进程需要按照特定的顺序执行。

为了实现同步，我们使用信号量机制来确保进程A和B按照正确的顺序执行。

3.2互斥在实验中，我们编写了多个进程C和D，这些进程需要同时对一个共享资源进行访问。

为了实现互斥，我们使用互斥锁机制来确保同一时刻只有一个进程访问共享资源。

4.实验过程4.1同步实验编写进程A和进程B的代码，使用信号量机制实现同步。

进程A先运行，然后通过信号量唤醒进程B，进程B再开始执行。

通过观察进程的运行顺序，验证同步机制是否起作用。

4.2互斥实验编写进程C和进程D的代码，使用互斥锁机制实现互斥。

进程C和进程D同时对一个共享资源进行访问，通过互斥锁来确保同一时刻只有一个进程访问共享资源。

观察进程的输出结果，验证互斥机制是否起作用。

5.实验结果5.1同步实验结果进程A开始执行进程A执行完毕进程B开始执行进程B执行完毕5.2互斥实验结果进程C开始执行进程C访问共享资源进程C执行完毕进程D开始执行进程D访问共享资源进程D执行完毕6.实验分析通过上述结果可以看出，同步实验中进程A和进程B按照正确的顺序执行，证明了同步机制的有效性。

互斥实验中进程C和进程D能够正确地交替访问共享资源，证明了互斥机制的有效性。

7.实验总结通过本次实验，我深刻理解了进程（线程）的同步与互斥，并通过实际操作加深了对这些概念的理解。

同步和互斥是操作系统中非常重要的概念，对于应对资源竞争和提高程序性能具有重要意义。

在实际开发中，我们应该合理使用同步和互斥机制，以确保程序的正确性和并发执行的效率。

多线程程序实验报告(3篇)

多线程程序实验报告(3篇)

第1篇一、实验目的1. 理解多线程的概念和作用。

2. 掌握多线程的创建、同步和通信方法。

3. 熟悉Java中多线程的实现方式。

4. 提高程序设计能力和实际应用能力。

二、实验环境1. 操作系统：Windows 102. 开发工具：IntelliJ IDEA3. 编程语言：Java三、实验内容本次实验主要完成以下任务：1. 创建多线程程序，实现两个线程分别执行不同的任务。

2. 使用同步方法实现线程间的同步。

3. 使用线程通信机制实现线程间的协作。

四、实验步骤1. 创建两个线程类，分别为Thread1和Thread2。

```javapublic class Thread1 extends Thread {@Overridepublic void run() {// 执行Thread1的任务for (int i = 0; i < 10; i++) {System.out.println("Thread1: " + i);}}}public class Thread2 extends Thread {@Overridepublic void run() {// 执行Thread2的任务for (int i = 0; i < 10; i++) {System.out.println("Thread2: " + i);}}}```2. 创建一个主类，在主类中创建两个线程对象，并启动它们。

```javapublic class Main {public static void main(String[] args) {Thread thread1 = new Thread1();Thread thread2 = new Thread2();thread1.start();thread2.start();}```3. 使用同步方法实现线程间的同步。

```javapublic class SynchronizedThread extends Thread {private static int count = 0;@Overridepublic void run() {for (int i = 0; i < 10; i++) {synchronized (SynchronizedThread.class) {count++;System.out.println(Thread.currentThread().getName() + ": " + count);}}}}public class Main {public static void main(String[] args) {Thread thread1 = new SynchronizedThread();Thread thread2 = new SynchronizedThread();thread1.start();thread2.start();}```4. 使用线程通信机制实现线程间的协作。

计算机操作系统实验报告

计算机操作系统实验报告

计算机操作系统实验报告一、实验目的本次计算机操作系统实验的主要目的是深入了解操作系统的工作原理和功能，通过实际操作和观察，增强对操作系统概念的理解，提高解决实际问题的能力。

二、实验环境1、操作系统：Windows 10 专业版2、开发工具：Visual Studio 20193、编程语言：C+＋三、实验内容1、进程管理实验创建多个进程，并观察它们的执行顺序和资源占用情况。

使用进程控制块（PCB）来跟踪进程的状态变化，如就绪、运行、阻塞等。

2、内存管理实验模拟内存分配和回收算法，如首次适应算法、最佳适应算法和最坏适应算法。

观察不同算法在内存利用率和分配效率方面的表现。

3、文件系统实验创建、读取、写入和删除文件，了解文件的操作流程。

研究文件的存储结构和目录管理方式。

4、线程同步与互斥实验使用互斥锁和信号量来实现线程之间的同步和互斥操作。

观察在多线程环境下资源竞争和同步的效果。

四、实验步骤1、进程管理实验步骤编写 C+＋程序，使用系统调用创建多个进程。

在每个进程中输出进程的标识符和当前执行时间。

通过观察控制台输出，分析进程的执行顺序和资源占用情况。

2、内存管理实验步骤实现不同的内存分配算法，并在程序中模拟内存请求和释放的过程。

记录每次内存分配和回收的结果，计算内存利用率和分配时间。

3、文件系统实验步骤使用文件操作函数创建文件，并写入一些数据。

读取文件中的数据，并将其输出到控制台。

删除文件，观察文件系统的变化。

4、线程同步与互斥实验步骤创建多个线程，共享一些公共资源。

在访问公共资源的代码段前使用互斥锁或信号量进行同步控制。

观察线程的执行结果，确保资源的正确访问和修改。

五、实验结果与分析1、进程管理实验结果与分析实验结果显示，进程的执行顺序是不确定的，取决于操作系统的调度策略和进程的优先级。

资源占用情况也因进程的不同而有所差异，一些进程可能占用较多的 CPU 时间和内存，而另一些则相对较少。

2、内存管理实验结果与分析首次适应算法在分配速度上较快，但容易产生内存碎片。