下载文档原格式
广州商学院操作系统实验报告（第 2 次）实验名称：进程的创建与并发执行之一实验时间：2021/3/31一．实验目的（1）理解进程与程序的联系与区别以及并发程序的基本特性。
（2）学会在在程序中使用fork() 函数创建克隆式子进程的基本编程方法。
二．实验内容命令进程的创建与并发执行三．实验主要步骤实验2.1 命令进程的创建与并发执行②启动Linux，进入黑屏界面；②在tty1上用root账号登录，在tty2和tty3上则分别以普通用户账号登录；③在tty1上输入命令“ps --help”，即在tty1上创建命令进程ps，以查看ps命令的help信息；④在tty2上输入命令“man man”，即在tty2上创建命令进程man，以查看man命令的help信息，不要终止该man命令；⑤在tty3上执行命令“man pstree”，即在tty3上创建命令进程man，查看pstree命令的help信息，同样也不要终止该man命令；⑥在tty1上执行ps命令，查看本控制台上所有进程的基本信息；⑦在tty1上执行pstree命令，查看进程的分层结构。
⑧再在tty1上执行ps命令，查看本系统的所有进程的详细信息，并从中找到并记下tty2上的man命令进程的PID；你能看到ps命令输出的全部信息吗？如果不能，可以利用Linux的“重定向”或“管道”功能，例如，可输入如下管道命令行：ps –aux | more该命令行的语义是：将ps命令的输出结果作为输入传递给more命令（分页显示），并执行more命令。
)⑨撤消tty2上的man命令进程；⑩再执行ps命令，查看被撤消的进程是否还存在；⑾切换到tty2，观察man命令是否还在执行或已终止；再切换到tty3，观察man命令是否还在执行或已终止；tty2（已经终止）tty3（未终止）⑿注销（不要关机）。
tty3tty2tty1实验2.2 使用fork创建进程本实验使用系统调用fork()创建多个子进程，实现多进程并发执行。
一、实验目的1. 理解线程的概念和并发编程的基本原理。
2. 掌握线程的创建、同步和通信方法。
3. 通过实验加深对线程并发编程的理解，提高编程能力。
二、实验环境1. 操作系统：Windows 102. 开发工具：Visual Studio 20193. 编程语言：C++三、实验内容本次实验主要涉及以下内容：1. 线程的创建与销毁2. 线程的同步与互斥3. 线程的通信4. 线程池的使用四、实验步骤1. 线程的创建与销毁（1）创建线程：使用C++11标准中的`std::thread`类创建线程。
```cpp#include <iostream>#include <thread>void threadFunction() {std::cout << "Thread ID: " << std::this_thread::get_id() << std::endl;}int main() {std::thread t1(threadFunction);std::thread t2(threadFunction);t1.join(); // 等待线程t1结束t2.join(); // 等待线程t2结束return 0;}```（2）销毁线程：线程会在任务执行完毕后自动销毁，无需手动销毁。
2. 线程的同步与互斥（1）互斥锁：使用`std::mutex`类实现线程间的互斥。
```cpp#include <iostream>#include <thread>#include <mutex>std::mutex mtx;void threadFunction() {mtx.lock();std::cout << "Thread ID: " << std::this_thread::get_id() << std::endl;mtx.unlock();}int main() {std::thread t1(threadFunction);t1.join();t2.join();return 0;}```（2）条件变量：使用`std::condition_variable`类实现线程间的条件同步。
实验二并发与调度一、实验目的在本实验中，通过对事件和互斥体对象的了解，来加深对Windows 2000线程同步的理解。
通过分析实验程序，了解管理事件对象的API。
了解在进程中如何使用事件对象，在进程中如何使用互斥体对象，线程如何通过文件映射对象发送数据。
二、实验环境硬件环境：计算机一台，局域网环境；软件环境：Windows 2000 Professional，Visual C++ 6.0专业版或企业版。
三、实验内容和步骤第一部分：互斥体对象本程序中显示的类CCountUpDown使用了一个互斥体来保证对两个线程间单一数值的访问。
每个线程都企图获得控制权来改变该数值，然后将该数值写入输出流中。
创建者实际上创建的是互斥体对象，计数方法执行等待并释放，为的是共同使用互斥体所需的资源(因而也就是共享资源) 。
1、利用互斥体保护共享资源程序参见实验指导书分析程序的运行结果，可以看到线程(加和减线程) 的交替执行(因为Sleep() API允许Windows切换线程) 。
在每次运行之后，数值应该返回初始值(0) ，因为在每次运行之后写入线程在等待队列中变成最后一个，内核保证它在其他线程工作时不会再运行。
1)请描述运行结果(如果运行不成功，则可能的原因是什么？) ：2) 根据运行输出结果，对照分析程序，可以看出程序运行的流程吗？请简单描述：_____逆向运行__________第二部分线程通过文件对象发送数据Windows 2000提供的线程间通讯类内核对象允许同一进程或跨进程的线程之间互相发送信息，包括文件、文件映射、邮件位和命名管道等，其中最常用的是文件和文件映射。
这类对象允许一个线程很容易地向同一进程或其他进程中的另一线程发送信息。
1、演示线程通过文件对象发送数据程序参见实验指导书运行结果(如果运行不成功，则可能的原因是什么？) ：阅读和分析程序，请回答问题：1) 程序中启动了多少个单独的读写线程？__________100__________________________________________________________2) 使用了哪个系统API函数来创建线程例程？_________ CreateThread（）________________________________3) 文件的读和写操作分别使用了哪个API函数？_______ ReadFile（）______ WriteFile（）_____________ 每次运行进程时，都可看到程序中的每个线程从前面的线程中读取数据并将数据增加，文件中的数值连续增加。
软件开发岗位实习报告：并发与并行编程实践经验一、导言在软件开发领域，随着计算机技术的不断发展，多核处理器的普及与应用，对于并发与并行编程的需求越来越迫切。
作为一名软件开发岗位的实习生，我有幸参与了一个项目，其中涉及到了并发与并行编程。
本次实习报告将总结我在项目中的实践经验，分享关于并发与并行编程的一些技巧和心得。
二、并发与并行编程的概念在开始进入实践经验的分享之前，我们先来了解一下并发与并行编程的概念。
并发编程是指程序的设计和实现中同时处理多个任务（称为线程）的能力。
在一个应用中，可以通过创建多个线程来执行不同的任务，从而提高系统的响应能力和效率。
并发编程的关键在于如何解决多个线程之间的并发访问和资源竞争问题。
而并行编程是指在物理上同时运行多个线程，利用多核处理器的优势，加速计算过程。
与并发编程相比，它更加追求任务的同时执行，尽量减少线程之间的等待时间。
三、并发编程的实践经验以下是我在实习过程中总结的一些并发编程的实践经验：1. 合理设计任务拆分：将一个大型任务拆分成多个小任务，然后通过创建多个线程并发执行这些小任务，可以提高程序的执行效率。
任务拆分的关键在于找准拆分的细粒度，尽量避免过细或过粗的拆分，以充分利用多线程的优势。
2. 注意线程之间的同步：线程之间的同步是并发编程中需要解决的关键问题。
通过适当使用锁机制、信号量、条件变量等同步手段，可以保证线程之间的互斥访问，避免数据竞争和死锁等问题。
3. 高效利用资源：在并发编程中，资源的合理利用是非常重要的。
例如，可以通过线程池来控制并发执行的线程数量，避免创建过多的线程，从而有效地管理系统资源。
4. 考虑异常处理：在并发编程中，由于多线程之间的相互依赖和调用，异常的处理变得比较复杂。
需要注意捕获和处理线程异常，保证程序的正确执行，并及时释放相应的资源。
四、并行编程的实践经验以下是我在实习过程中总结的一些并行编程的实践经验：1. 合理地任务划分：针对计算密集型任务，可以将任务划分为多个小任务，并行执行，将计算压力均匀地分散到多个处理器核心上，提高计算效率。
一、实验目的1. 理解并发执行的概念和原理。
2. 掌握多线程编程的基本方法。
3. 学会使用同步机制解决并发编程中的竞争条件。
4. 分析并发程序的性能和效率。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：Eclipse三、实验内容1. 创建一个简单的并发程序，实现两个线程同时执行。
2. 使用同步机制解决并发程序中的竞争条件。
3. 分析并发程序的性能和效率。
四、实验步骤1. 创建一个简单的并发程序（1）创建一个名为ConcurrentTest的类，该类继承自Thread类。
（2）在ConcurrentTest类的run方法中，打印出当前线程的名字。
（3）在主函数中，创建两个ConcurrentTest对象，分别命名为thread1和thread2。
（4）启动thread1和thread2线程。
（5）等待thread1和thread2线程执行完毕。
2. 使用同步机制解决并发程序中的竞争条件（1）创建一个名为Counter的类，该类包含一个私有变量count和一个静态同步方法add。
（2）在add方法中，增加count变量的值。
（3）在主函数中，创建一个Counter对象counter。
（4）创建两个线程，分别调用counter对象的add方法。
（5）启动两个线程，并等待它们执行完毕。
3. 分析并发程序的性能和效率（1）在主函数中，记录两个线程开始执行的时间。
（2）在主函数中，记录两个线程执行完毕的时间。
（3）计算两个线程执行所需的时间差。
五、实验结果与分析1. 实验结果（1）简单的并发程序在控制台中，可以看到thread1和thread2线程交替打印出它们的名字。
（2）使用同步机制解决竞争条件在控制台中，可以看到Counter对象的count变量值正确地增加了。
（3）分析并发程序的性能和效率thread1和thread2线程执行所需的时间差为0.01秒。
2. 实验分析（1）简单的并发程序通过创建两个线程，实现了两个任务同时执行。
一、实验背景与目的随着计算机技术的发展，多任务处理和多进程并发已经成为操作系统设计中的基本要求。
为了更好地理解进程并发的基本原理和实现方法，我们进行了本次实验。
实验的目的是通过实践操作，加深对进程并发执行的理解，掌握进程创建、同步、互斥等基本概念，并学会使用相关系统调用实现进程的并发控制。
二、实验环境与工具实验环境：Windows 10操作系统，Visual Studio 2019开发环境。
实验工具：C++编程语言，WinAPI系统调用。
三、实验内容与步骤本次实验主要分为以下几个部分：1. 进程创建与并发执行- 使用CreateProcess函数创建多个进程，并观察它们的并发执行情况。
- 使用GetTickCount函数获取每个进程的执行时间，分析并发执行的效果。
2. 进程同步- 使用互斥锁（mutex）实现进程间的同步，确保同一时刻只有一个进程访问共享资源。
- 使用条件变量（condition variable）实现进程间的条件同步，实现生产者-消费者模型。
3. 进程互斥- 使用信号量（semaphore）实现进程间的互斥，避免资源竞争。
- 使用临界区（critical section）保护共享资源，防止多个进程同时访问。
4. 实验分析- 分析实验结果，总结进程并发、同步和互斥的原理和方法。
- 讨论实验中遇到的问题和解决方法。
四、实验代码示例以下是一个简单的实验代码示例，演示了使用互斥锁实现进程同步的过程：```cpp#include <windows.h>#include <iostream>using namespace std;// 全局互斥锁mutex mtx;void processFunction(){unique_lock<mutex> lock(mtx);cout << "Process " << GetCurrentProcessId() << " is running." << endl;lock.unlock();}int main(){// 创建两个进程CreateProcess(NULL, "process.exe", NULL, NULL, FALSE, 0, NULL, NULL, NULL, NULL);// 主进程继续执行cout << "Main process is running." << endl;return 0;}```五、实验结果与分析1. 进程创建与并发执行通过实验，我们观察到多个进程可以并发执行，并且每个进程的执行时间都会有所不同。
多线程并发实验报告心得
一、实验介绍
本次实验是多线程并发实验，旨在通过编写多线程程序，掌握多线程编程的基本原理和技巧，并了解并发程序的运行机制。
二、实验环境
本次实验使用Java语言，在Eclipse开发环境下完成。
三、实验过程
1. 熟悉多线程编程的基本原理和技巧，包括线程的创建、启动、休眠等操作；
2. 编写多线程程序，模拟多个人同时购买火车票的场景；
3. 在程序中设置同步锁，保证只有一个人能够购买到票；
4. 运行程序，观察并发程序的运行机制。
四、实验结果
经过多次测试和调试，我们成功地编写出了一个模拟购票系统的多线程程序。
在运行过程中，我们观察到不同线程之间存在竞争关系，并且通过设置同步锁，保证了只有一个人能够成功购买到票。
五、心得体会
通过本次实验，我深刻地认识到了并发编程的重要性。
在日常开发中，很多应用都需要支持并发访问，在不加注意的情况下很容易出现资源
竞争等问题。
因此，在进行并发编程时，我们必须充分考虑并发访问
的可能性，并采取相应的措施来保证程序的正确性和稳定性。
同时，我也认识到了多线程编程的复杂性。
在编写多线程程序时，我
们需要考虑线程之间的协作关系、同步锁的设置、异常处理等问题，
这些都需要我们具备较高的编程技能和经验。
因此，在进行多线程编
程时，我们需要仔细思考，并且不断地积累经验。
最后，我认为本次实验对我的编程能力提升有很大帮助。
通过实践操作，我深入了解了多线程并发编程的原理和技巧，并且掌握了一些实
用的技巧和方法。
相信这些知识和经验将对我的日常开发工作产生积
极影响。
一、实验目的1. 了解并发执行的概念和原理。
2. 学习并发编程技术，提高程序执行效率。
3. 通过实验验证并发执行对程序性能的影响。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：IntelliJ IDEA4. 并发框架：Java并发包（java.util.concurrent）三、实验内容1. 实验一：线程同步2. 实验二：线程池3. 实验三：并发容器4. 实验四：Future和Callable四、实验步骤1. 实验一：线程同步（1）创建一个共享资源，用于模拟多个线程对资源的访问。
（2）使用synchronized关键字实现线程同步。
（3）比较同步前后程序执行时间。
2. 实验二：线程池（1）创建一个线程池，并提交多个任务到线程池中执行。
（2）比较线程池和普通线程执行任务的效率。
3. 实验三：并发容器（1）使用并发容器（如ConcurrentHashMap）和普通容器（如HashMap）进行数据操作。
（2）比较两种容器在并发环境下的性能差异。
4. 实验四：Future和Callable（1）使用Callable接口和Future接口实现异步计算。
（2）比较使用Future和Callable前后程序执行时间。
五、实验结果与分析1. 实验一：线程同步实验结果显示，在同步前，程序执行时间为5秒；在同步后，程序执行时间为2秒。
这说明线程同步可以有效地提高程序执行效率。
2. 实验二：线程池实验结果显示，在普通线程环境下，程序执行时间为10秒；在线程池环境下，程序执行时间为6秒。
这说明线程池可以显著提高程序执行效率。
3. 实验三：并发容器实验结果显示，在并发环境下，使用并发容器（如ConcurrentHashMap）的平均执行时间为1秒，而使用普通容器（如HashMap）的平均执行时间为3秒。
这说明并发容器在处理并发操作时具有更好的性能。
4. 实验四：Future和Callable实验结果显示，使用Future和Callable接口实现异步计算后，程序执行时间为4秒；而同步执行程序执行时间为8秒。
一、实验名称实验二并发与调度二、实验目的在本实验中，通过对事件和互斥体对象的了解，来加深对Windows Server 2003线程同步的理解。
1) 回顾系统进程、线程的有关概念，加深对Windows Server 2003线程的理解。
2) 了解事件和互斥体对象。
3) 通过分析实验程序，了解管理事件对象的API。
4) 了解在进程中如何使用事件对象。
5) 了解在进程中如何使用互斥体对象。
6) 了解父进程创建子进程的程序设计方法。
三、实验内容父进程启动时，利用CreateEvent() API创建一个命名的、可共享的事件和子进程，然后等待子进程向事件发出信号并终止父进程。
在创建时，子进程通过OpenEvent() API打开事件对象，调用SetEvent() API使其转化为已接受信号状态。
两个进程在发出信号之后几乎立即终止。
四、实验步骤步骤1：登录进入Windows Server 2003 。
步骤2：在“开始”菜单中单击“程序”-“Microsoft Visual Studio 6.0”–“Microsoft Visual C++ 6.0”命令，进入Visual C++窗口。
步骤3：在工具栏单击“打开”按钮，在“打开”对话框中找到并打开实验源程序4-1.cpp。
步骤4：单击“Build”菜单中的“Compile 4-1.cpp”命令，并单击“是”按钮确认。
系统对4-1.cpp进行编译。
步骤5：编译完成后，单击“Build”菜单中的“Build 4-1.exe”命令，建立4-1.exe可执行文件。
操作能否正常进行？如果不行，则可能的原因是什么？_ 操作能正常运行。
________________步骤6：在工具栏单击“Execute Program”(执行程序) 按钮，执行4-1.exe程序。
运行结果(分行书写。
如果运行不成功，则可能的原因是什么？) ：1) ___event created______________________________________________________________2) ___child created_______________________________________________________________3) ___Parent waiting on child._____________________________________________ ________4) ___child process begining……_________________________ ___________________________5) ___ event signaled______________________________________________________________6) ___ parent received the envent signaling from child_________________________________7) ___ Parent released._____________________________________________________________这个结果与你期望的一致吗？(从进程并发的角度对结果进行分析)答：这个结果与期望一致。
多线程并发实验报告心得一、背景介绍在计算机科学领域中，多线程并发是一种常见的编程模型，可以显著提升程序的执行效率。
多线程并发技术允许程序同时执行多个任务，每个任务都可以独立运行，并且可以在适当的时候进行交互和同步。
通过合理地使用多线程并发，可以充分利用计算机系统的资源，提高程序的整体性能，使得用户在使用软件时能够得到更好的体验。
二、实验目的本次实验的主要目的是通过编写多线程并发程序，探索多线程并发技术的优势和局限性。
具体来说，我们需要实现一个具备一定复杂度的多线程并发程序，并通过实验和心得总结来分析该程序在不同运行环境下的表现以及优化策略。
三、实验内容1. 设计具备一定复杂度的多线程并发程序在本次实验中，我们选取了一个常见的多线程并发程序设计场景：模拟多个用户同时访问某个资源（如服务器、数据库等），并对该资源进行读写操作。
具体来说，我们设计的程序拥有以下特点： - 程序启动时自动生成多个用户线程，每个用户线程独立运行。
- 每个用户线程具有不同的访问频率、读写操作和等待时间。
- 用户线程之间需要进行同步操作，以保证数据的一致性和正确性。
2. 实验环境搭建为了测试多线程并发程序在不同运行环境下的性能表现，我们搭建了几个不同配置的机器，并安装了相应的操作系统、编程语言和开发工具。
具体来说，我们使用了以下配置的机器： - 主机A：16核CPU、32GB内存、1TB硬盘，Ubuntu操作系统。
- 主机B：8核CPU、16GB内存、500GB硬盘，Windows操作系统。
- 虚拟机C：4核CPU、8GB内存、200GB硬盘，CentOS操作系统。
同时，我们采用C++语言编写了多线程并发程序，并在主机A、主机B和虚拟机C上进行了编译和运行。
3. 实验结果分析我们在上述三个不同配置的机器上分别运行了多线程并发程序，并记录了程序的执行时间、内存占用和CPU利用率。
通过对比不同机器上的实验结果，我们得出了以下结论： 1. 随着硬件资源的增加，程序的执行时间逐渐减少，因为更多的硬件资源可以有效提升并发程序的执行效率。
实验数据库并发控制实验目的：了解并掌握数据库的保护措施——并发控制机制，重点以SOL Server2000为平台加以操作实践，要求认识典型并发问题的发生现象并掌握解决办法。
实验背景：并发操作是数据库共享特性的一个体现，但却对数据库德一致性和完整性形成了巨大的危机。
事务是并发控制的基本单位。
SOL Server2000的事务一般分为2类，一种是系统提供的事务，是指在执行语句时，一条语句就是一个事务；另一种是用户定义的事务，即用户明确定义的事务。
在实际应用中大多数事务需要由用户自己定义事务来出来。
用BEGING TRANSACTION定义事务的开始；用COMMIT TRANSACTION来成功提交事务；用ROLLBACK TRANSACTION 将事务操作全部取消。
SOL Server2000采用加锁技术确保事务运行不会影响数据库的一致性和完整性。
加锁技术可以防止用户读取正在由别的用户修改的数据，也可以防止两个用户同时修改同一个数据。
如果没有锁，数据库中的数据可能出现丢失修改、脏读、不可重复读、幻影等并发问题。
虽然SOL Server2000自动强制锁定，但是可以通过了解锁定并在应用程序中自定义锁来设计更有效的并发控制程序。
SOL Server2000提供了如下类型的锁：共享(S)、更新(U)、排它(X)、意向锁、架构锁、大容量更新(BU)，详见联机丛书《SQL Server 中的锁定介绍》。
SQL Server 2000 具有多粒度锁定，允许一个事务锁定不同类型的资源。
隔离属性是ACID 的四个属性之一，逻辑工作单元必须具备这四个属性才能称为事务。
该属性能够使事务免受其它并发事务所执行的更新的影响。
每个事务的隔离级别实际上都是可以自定义的。
当锁定技术实施并发控制机制时，使所有事务得以在彼此完全隔离的环境中运行，但是任何时候都可以有多个正在运行的事务。
可串行性保证一组并发事务运行后所达到的数据库状态，等同于这组事务按某种顺序连续执行时所达到的数据库状态。
并发测试报告1. 引言作为软件测试的一种重要手段，并发测试旨在验证系统在同一时间内能够处理多个并发用户或进程的能力。
本文将针对某应用进行并发测试，并总结并发测试报告。
2. 测试环境准备在进行并发测试之前，我们需要先搭建测试环境。
测试环境的搭建包括准备测试用例、配置测试服务器和客户端等。
在本次测试中，我们选择了一款电商应用作为测试对象，并搭建了一台服务器和多台客户端用于模拟并发操作。
3. 测试目标和策略并发测试的目标是验证系统在极限负载下的性能表现，并发操作可能导致的问题以及系统的稳定性。
因此，在本次测试中，我们将通过模拟大量用户同时访问系统、并且同时进行下单、支付等操作，来评估系统在压力下的表现。
4. 测试执行与结果分析在测试的过程中，我们通过逐步增加并发用户数量的方式，观察系统的反应和性能指标。
测试过程中，我们记录了以下指标以进行结果分析：- 响应时间：系统对并发请求的响应时间是否能够保持在可接受范围内；- 吞吐量：系统每秒可以处理的请求数量；- 错误率：并发操作是否会导致系统崩溃或出现错误；- 资源利用率：测试过程中系统所使用的CPU、内存等资源的利用率。
在测试过程中，我们发现系统的响应时间随着并发用户数量的增加而逐渐增加，但整体上保持在合理范围内。
吞吐量逐渐增加，并在某一点达到峰值后趋于稳定。
系统在高并发情况下，错误率有所上升，但并未出现系统崩溃等严重问题。
同时，系统在测试过程中的资源利用率保持在较为稳定的水平。
5. 结论与建议综上所述，本次并发测试表明系统在一定程度上能够处理并发操作，并且在负载逐渐增加的情况下性能表现良好。
然而，随着并发用户数量的增加，系统的响应时间仍有上升的趋势，可能需要进一步优化。
针对本次测试结果，我们提出以下建议：- 对系统进行性能优化，提高并发用户数量下的响应速度；- 进一步完善系统容错机制，降低并发操作导致错误的概率；- 加强系统资源管理，以提高资源利用率。
6. 总结本次并发测试报告总结了对某电商应用系统的并发性能测试结果，并给出了进一步优化的建议。
附录一程序代码#include<stdio.h>#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>#include<unistd.h>#include<pthread.h>#define PSIZE 4096 /*管道文件的大小*/#define BSIZE 128 /*默认缓冲区的大小*/#define NOFILE 20 /*u_ofile表可分配的个数*/#define NFILE 20 /*p_file表可分配的个数*/#define NPIPE 20 /*p_fcb可分配的个数*//*进程的u_file表*/int u_ofile[NOFILE];/*模拟file表*/struct{char f_flag;/*读写标志，'w'表示写，'r'表示读*/int f_count;/*表示此表项的状态，=0表示此表项没被使用，可分配；=1表示此表项在被使用，不可再分配*/int f_inode;/*对应的p_fcb表下标*/long f_offset;/*读写指针，当前已读或已写个数*/}p_file[NFILE];/*管道控制块*/struct{char *p_addr;/*管道文件基地址*/int p_size;/*管道文件大小，PSIZE*/int p_count;/*=2表示读写都在被进行，=1表示在被读或被写，=0表示管道没被使用，可分配*/}p_fcb[NPIPE];/*模拟管道文件*/char *pfile;/*管道的写入写出端*/int fd[2];/*锁机制，实现互斥*/pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;/*进程间通信，实现同步*/pthread_cond_t rflag = PTHREAD_COND_INITIALIZER;/*读信号量*/pthread_cond_t wflag = PTHREAD_COND_INITIALIZER;/*写信号量*//*线程创建函数只能传一个参数，用结构体来封装所有参数*/struct arg_set{char *fname; /*文件名*/int f; /*传递fdp[]*/};/*u_ofile表初始化*/int u_ofile_init(){int i;for(i=0;i<NOFILE;i++)u_ofile[i] = -1;u_ofile[0]=0;u_ofile[1]=0;u_ofile[2]=0;return 0;}/*创建管道*/int ppipe(int a[]){int i;for(i=0;i<NOFILE;i++){if(u_ofile[i]==-1){a[0] = i;/*读*/u_ofile[i] = 0;/*读端*/break;}}for(i;i<NOFILE;i++){if(u_ofile[i]==-1){a[1] = i;/*写*/u_ofile[i] = 1;/*写端*/break;}}if(i>=NOFILE){printf("u_ofile分配失败\n");return -2;}pfile = (char *)malloc(PSIZE*sizeof(char));/*申请模拟管道用的内存空间*/if(pfile==NULL)/*申请可能不成功*/{return -1;}for(i=0;i<NFILE;i++){if(p_file[i].f_count!=1){p_file[i].f_flag = 'r';/*读标志*///p_file[i].f_inode = 0;/*读对应p_fcb表下标*/p_file[i].f_count = 1;/*p_file[0]这个表项在被使用，不可再分配*/ p_file[i].f_offset = 0;/*读指针*/u_ofile[a[0]] = i;/*读端*/break;}}for(i=0;i<NFILE;i++){if(p_file[i].f_count!=1){p_file[i].f_flag = 'w';/*写标志*///p_file[i].f_inode = 0;/*写对应p_fcb控制块下标*/p_file[i].f_count = 1;/*p_file[1]这个表项在被使用，不可再分配*/ p_file[i].f_offset = 0;/*写指针*/u_ofile[a[1]] = i /*写端*/break;}}if(i>=NFILE){return -1;}for(i=0;i<NPIPE;i++){if(p_fcb[i].p_count==0){p_fcb[i].p_addr = pfile;/*给管道文件基地址赋值*/p_fcb[i].p_size = PSIZE;/*管道文件大小*/p_fcb[i].p_count = 2;/*读写都在进行，此p_fcb表项不可再分*/p_file[u_ofile[a[0]]].f_inode = i;p_file[u_ofile[a[1]]].f_inode = i;break;}}if(i>=NPIPE){return -1;}return 0;/*分配成功*/}/*关闭管道*//int p_close(int a[]){char *p;int i;for(i=0;i<2;i++){p=p_fcb[p_file[u_ofile[a[i]]].f_inode].p_addr;if(p!=NULL)free(p); /*释放管道内存*/p_fcb[p_file[u_ofile[a[i]]].f_inode].p_count = 0; /*管道控制块计数清零*/p_file[u_ofile[a[i]]].f_count = 0; /*file表项计数清零*/u_ofile[a[i]] = -1; /*u_ofile表项清空*/a[i] = -1; /*fdp[]清空?/}return 0;}/*写管道*/int writep(int fd,char *ca,int n){long offr,offw;/*读写指针，实际是读写字符个数*/int r;/*管道文件读端*/int m;/*若ca中的字符不能一次写完，m用来表示一次可写入的字符的最大数*/ int w = u_ofile[fd];/*管道文件写端*/int pf = p_file[w].f_inode;/*读管道对应的p_fcb表的下标*/int n1 = n;/*一次应该写入的字符个数*/int wstart = 0;/*计数器，写入字符个数*/int i = 0for(i;i<NFILE;i++)/*寻找写管道对应的读管道的读端*/{if((p_file[i].f_flag=='r')&&(p_file[i].f_inode==pf)){r = i;break;}else{continue;}}pthread_mutex_lock(&lock);/*互斥锁，相当于进入临界区*/offr = p_file[r].f_offset;/*赋值读指针*/offw = p_file[w].f_offset;/*赋值写指针*/if((offw+n1-PSIZE)>offr)/*不能一次写完*/{if(p_fcb[pf].p_count==0)/*对文件的复制操作已进行结束，管道文件被释放*/{return 0;}else{m = PSIZE+offr-offw;/*最多可写入数*/for(wstart=0;wstart<m;wstart++){*(p_fcb[pf].p_addr+offw%PSIZE) = *ca;ca++;offw++;}p_file[w].f_offset = offw;/*重定位写指针位置*/n1 = n1-m;/*剩余需要读的字符个数*/pthread_cond_signal(&rflag);/*唤醒读线程，管道可读*/pthread_cond_wait(&wflag,&lock);/*写线程封锁等待*/}}/*一次性可将ca中内容全部写入管道*/offr = p_file[r].f_offset;offw = p_file[w].f_offset;for(wstart=0;wstart<n1;wstart++){/*printf("%d\n",p_fcb[pf].p_addr);*/*(p_fcb[pf].p_addr+offw%PSIZE) = *ca;/*printf("%d\n",wstart);*/ca++;offw++;}p_file[w].f_offset = offw;pthread_cond_signal(&rflag);pthread_mutex_unlock(&lock);return n;/*返回写入字符个数*/}/*读管道*/int readp(int fd,char *ca,int n){long offr,offw;/*读写指针，实际是读写字符个数*/int w;/*管道文件写端*/int m;/*若ca中的字符不能一次读完，m用来表示一次可读出的字符的最大数*/ int r = u_ofile[fd];/*管道文件读端*/int pf = p_file[r].f_inode;/*读管道对应的p_fcb表的下标*/int rstart = 0;/*计数器，读出字符个数*/int i = 0;for(i;i<NFILE;i++)/*寻找读管道对应的读管道的端*/{if((p_file[i].f_flag=='w')&&(p_file[i].f_inode==pf)){w = i;break;}else{continue;}}pthread_mutex_lock(&lock);/*互斥锁，相当于进入临界区*/offr = p_file[r].f_offset;/*赋值读指针*/offw = p_file[w].f_offset;/*赋值写指针*/if(offr==offw)/*管道空，无内容可读*/{if(p_fcb[pf].p_count==1)/*写端关闭*/{p_fcb[pf].p_count--;/*文件的复制以完成，释放管道文件的空间*/return 0;}else{pthread_cond_signal(&wflag);/*唤醒写线程，管道可写*/pthread_cond_wait(&rflag,&lock);/*写线程封锁等待*/}}offr = p_file[r].f_offset;offw = p_file[w].f_offset;m = n<=(offw-offr)?n:(offw-offr);/*得到可读字符个数*/for(rstart=0;rstart<m;rstart++){*ca = *(p_fcb[pf].p_addr+offr%PSIZE);ca++;offr++;}p_file[r].f_offset = offr;/*重定位读指针位置*/pthread_cond_signal(&wflag);pthread_mutex_unlock(&lock);return m;}/*线程调用，读源文件，写管道*/void *pwrite(void *a){char abuf1[BSIZE];struct arg_set *args=(struct arg_set *)a;/*需要传入多个参数时，用结构体传*/int fdr;int n_r;/*管道文件写入字符数*/if((fdr=open(args->fname,O_RDONLY))!=-1){while((n_r=read(fdr,abuf1,BSIZE))>0)/*读文件，写管道*/writep(args->f,abuf1,n_r);p_fcb[p_file[u_ofile[args->f]].f_inode].p_count--;/*文件已读完，关闭管道写端*/ }else{perror(args->fname);/*打开源文件可能不成功*/}return NULL;}/*线程调用，写目标文件，读管道*/void *pread(void *a){char abuf2[BSIZE];/*缓冲区*/struct arg_set *args=(struct arg_set *)a;/*需要传入多个参数时，用结构体传*/int fdw;int n_w;/*管道文件读出字符数*/if((fdw=open(args->fname,O_CREAT|O_RDWR,0777))!=-1){while((n_w=readp(args->f,abuf2,BSIZE))>0)/*读管道，写文件*/write(fdw,abuf2,n_w);}else{perror(args->fname);/*打开目标文件可能出错*/}return NULL;}/*主函数*/int main(int argc,char *argv[]){int x;u_ofile_init();while((x=ppipe(fd))==-1);/*创建管道，即申请空间*/if(x==-2)return -1;pthread_t t;struct arg_set args[2];/*用结构体传写线程需要的参数:文件名,管道文件读写端*/ args[0].fname=argv[1];/*源文件名*/args[0].f=fd[1];/*管道文件写端*/args[1].fname=argv[2];/*目标文件名*/args[1].f=fd[0];/*管道文件读端*/pthread_create(&t,NULL,pwrite,(void *)&args[0]);/*创建子线程,写管道*/pread((void *)&args[1]);/*主线程调用,读管道*/pthread_join(t,NULL);/*等待写线程结束*/p_close(fd);return 0;}附录二实验结果1.小型文本文件测试：2．中型文本文件测试：3．大型文本文件测试：4．生成的目标文件与源文件的比较：。
河南师范大学综合性、设计性实验项目简介
Linux内置的Telnet客户端连接情况
Windows内置的Telnet客户端连接情况采用并发设计服务端程序对于多用户连接也是工作正常的：
相应的客户端端程序可以正确与服务器交互（不过客户端还是很简陋的，还没有通用性）：
1、UNIX（Linux）中，终端输入在缺省情况下是被“一锅端”的，也就是说整行输入是被一起处理的。
它意味着在读入数据时必须按一下回车键表示输入行结束后才能得到输入的数据。
为了得到对每一个键盘输入的相应，我采用了system( "stty raw -echo" )来开启终端驱动的一次一字符模式。
2、由于发送缓冲区的存在，每次write之后数据不是立刻发送到对方的，可能是将多次write的数据一起送达，这就对数据过滤造成了一些麻烦。
Telnet交互类似于一种状态机模式，假如要写出健壮的程序就只好对数据包的每个字节进行分析了。
注：开课时间填本实验项目所有实验班的具体上课时间，如11月12日下午3：00－5：00。
Chhd并发测试报告一、测试目的1、测试典型页面能支持的最大并发用户数。
2、测试典型页面在响应时间为10s的时间内，能支持的最大并发数。
二、选择的典型页面及并发点1、登录首页http://192.168.1.10。
并发点：同时打开这个链接。
2、打开页面http://192.168.1.10,点击页面上的“市场准入”。
并发点：同时点击“市场准入”链接。
3、打开市场准入页面http://192.168.1.10/220000.shh，点击页面上的“企业资质检索”。
并发点：同时点击“企业资质检索”。
4、打开市场准入页面http://192.168.1.10/220000.shh，点击页面上的“市场准入讨论版”。
并发点：同时点击“市场准入讨论版”。
5、打开申报指导栏目页面http://192.168.1.10/220300.shh，点击“确定”并发点：同时点击“确定”。
三、“并发打开首页”脚本、场景设计及测试结果分析（测试最大并发用户数）说明：采用逐步加压方式，即每隔1s增加一个用户，全部加压完后，在集合点释放，并发开始，215是个边界值，当增加到216时，就会出现timeout提示。
3.3 测试结果及分析3.3.1事务响应时间图图1由上图1可以看到，事务“首页”的平均响应时间为89.291s，一分多钟了，比较长。
3.3.2 事务细分图分析一个应用程序是由很多个组件组成的,图2显示了整个测试过程中涉及到的页面http://192.168.1.10的组件组成及下载情况，由图可以看到该页中包括的css样式表,js脚本,jsp页面以及图片等所有的属性.图2仔细观察可以发现，下载public.js脚本的时间最长，主要用在了First Buffer 和connection中。
First Buffer：显示从初始HTTP 请求（通常为GET）到成功收回来自Web 服务器的第一次缓冲时为止所经过的时间。
第一次缓冲度量是很好的Web 服务器延迟和网络滞后指示器。
实验1 进程并发问题
学时：4学时
实验目的:
理解操作系统中进程之间的并发，以及并发的控制。
实验要求:
在掌握操作系统原理中的进程的基本概念之上，通过模拟两个进程进一步理解进程并发，通过设置优先级或到达时间来对进程并发作控制。
实验内容：
编写两个函数来模拟两个进程，一个循环做N=N+1；另一个循环做print(N)；N初值为0，要求模拟在二者速度不同的情况下，分别出现以下3种输出结果：
① 1 2 3 4 5 6……
② 1 3 5 7 9 11……
③ 1 1 2 2 3 3 4 4……
注：两个进程要设计出并发控制的条件，优先级或到达时间均可，注意其数据结构的使用，以及并发时的参数调整。
电子科技大学通信学院
《网络软件设计实验报告》
并发服务
班级
学生
学号
教师
模板资料资源共享
并发服务实验
【实验目的】
1、掌握并发服务程序设计的特点
2、体会并发服务程序执行特点
3、了解进程（线程）控制、调度的原理和方法
【实验环境】
两人或三人一组实验，也可作为教师演示性实验。
【实验原理】
（见实验指导书相关部分）
【实验方法】
在中级阶段的程序中设计和实现主线程及子线程的核心部分。
利用对比实验感受设计成果。
利用VC的Spy工具观察进程和线程的状态。
【实验步骤】
1.实验前可先利用MSDN或查阅相关书籍了解本实验的重点实验对象：CreateThread（）函数的使用方法及相关知识。
2.打开服务器工程，先来感受一下多线程并发执行的情况。
使用CtreateThread创建线程：服务器将在接受每个客户的连接时创建一个新线程，线程执行server_proc_test( )，该函数的原理是在一段空循环造成的延时后打印套接字，整个过程将不断反复进行，实验者可以观察到线程不断打印套接字标识符的现象，并进一步通过不同的线程打印不同的套接字标识符来体会线程之间调度的情况。
在程序中，实验者可以通过调整空循环的次数，使线程一次连续输出的次数控制在3～10个，以便观察。
请连续启动4～5个客户机，观察多线程独立调度的情况。
2
当多个客户机连接后让程序执行一段时间，（如输出结果有4行以上），使用Break键，暂时停止系统，记录各线程输出结果的序列：
观察这个序列，特别注意各线程每次连续输出的个数是否一定相等：（即考察线程分得的时间片情况）。
各线程的输出结果是否一定按照固定的顺序轮流出现：，（多观察一些数据，本环节考察线程独立调度的情况）。
3.使用任务管理器观察CPU使用率，了解多线程下对CPU的使用情况。
按Ctrl＋Alt＋Del，
产生多个线程以前CPU的使用率：，
产生多个线程以后的CPU使用率：。
4.停止测试，回到服务器工程，这一次设计子线程执行函数：server_proc（）。
要求：子线程控制一次连接的通信过程，即从客户端接收到一个字符串，打印，并发送回去一个确认字符串。
这样，服务器就只接收连接，而线程只在已建立连接的套接字上完成通信。
请记录server_proc的流程（简要的语言描述核心功能）：
5.执行服务器，连续执行多个客户机，并尝试和服务器通信。
多个客户机是否能与服务器同时通信：。
6.使用任务管理器观察CPU利用率，和步骤3对比，思考为什么CPU利用率下降了。
3
多条连接并发服务下，CPU的使用率：。
7.打开spy++，在进程窗口里，查找COSERVER（注意大写）进程，找到后展开该进程，观察属于该进程的线程的情况。
spy＋＋在Microsoft visual studio 6.0的Microsoft visual studio 6.0 tools下。
查找进程时，注意将待查进程的ID栏删空，在进程MODLUE栏中填入进程外部名：COSERVER，如图：
COSERVER有多少个线程：，当前与服务器建立连接的客户机数量：。
8.对比实验，将创建线程的语句改为直接调用server_proc（）——即替换CreateThread为server_proc，不是步骤4中只是将CreateThread的参数3改为server_proc 。
测试这样的服务能否实现多路复用，对比步骤5，体会多线程并发服务的效果。
单个客户机能否实现与服务器的正常通信：，
多个客户机同时连接服务器，能否实现多路复用：，
使用spy＋＋观察，COSERVER有多少个线程：，当前与服务器建立连接的客户机数量：。
9.测试参数4——在主线程和子线程之间传递参数的方法。
再次替换server_proc为CreateThread，改参数3为server_proc_test2。
——server_proc_test2()功能是打印输入的参数，在打印之前使用gets()阻塞子线程的执行。
1）重新编译，并运行服务器程序。
2）执行客户机程序，观察服务器的输出，此时服务器希望传递给子线程的套接字标识符为：。
4
3）不关闭客户机的情况下，再次执行客户机程序，得到客户2，观察服务器的输出，，此时服务器希望传递给子线程的套接字标识符为：。
4）在服务器窗口内随便输入一个字符串，然后按回车键结束。
gets()的功能是从键盘输入一个字符串，以回车作为结束。
在本实验中我们利用这个功能来暂时阻塞子线程，然后再通过人工输入的方式控制子线程继续。
子线程继续执行以后，将取得传入的套接字标识符：。
再次输入一个字符串，以回车结束，子线程2也继续运行，取得了自己的传入参数：。
5）对比希望传入的和实际传入的参数，发生了什么现象：
6）请根据指导书的提示，改写主线程和server_proc_test2中相关语句，完成正确的参数传递.
主线程修改的语句为：
子线程修改的语句为：
启动测试，按步骤1）～5），希望传入的参数分别为：
实际得到的参数为：
是否正确传递了参数：。
【实验结果分析及结论】
（提示：多线程并发服务的特点）
5
【思考】
1、通过分析步骤2的实验现象，你对线程的调度有些什么体会？
2、步骤5的实验现象和之前的哪个实验的现象类似？为什么并发服务可以提供
多路复用的功能？
3、为什么利用spy看到的COSERVER的线程个数比实际因客户连接而创建的线
程数多一个？
4、本实验中服务器创建的子线程将在何时结束？
6。
