linux使用多线程解决“读者—写者”问题实验报告
读者写者问题实验报告
读者写者问题实验报告1. 引言读者写者问题是操作系统中的经典同步问题，用于研究多线程环境下对共享资源的访问和保护。
在该问题中，有多个读者和写者同时对一个共享资源进行操作，需要保证并发访问时的正确性和效率。
通过本实验，我们将探讨读者写者问题的解决方案，并比较不同算法的性能差异。
2. 实验目标本实验的主要目标是通过实现和比较不同的读者写者问题算法，深入了解并发访问的挑战和解决方案。
具体而言，我们将研究以下几个方面：•设计并实现读者写者问题的解决方案•比较不同算法的性能差异•分析可能的优化策略3. 实验方法我们将使用Python编程语言来实现读者写者问题的解决方案。
在实验过程中，我们将尝试以下几种常见的算法：3.1. 读者优先算法在读者优先算法中，当有读者在访问共享资源时，其他读者可以同时访问，但写者需要等待。
只有当所有读者完成访问后，写者才能获得访问权限。
3.2. 写者优先算法在写者优先算法中，当有写者在访问共享资源时，其他读者和写者都需要等待。
只有当写者完成访问后，其他读者或写者才能获得访问权限。
3.3. 公平算法在公平算法中，读者和写者的访问权限是公平的，先到先得。
无论读者还是写者，都需要按照到达的顺序依次获取访问权限。
4. 实验步骤下面是我们实施实验的具体步骤：4.1. 实现基本的读者写者问题解决方案我们首先实现基本的读者写者问题解决方案，包括读者和写者的线程逻辑和共享资源的访问控制。
我们将使用互斥锁和条件变量来保证并发访问的正确性。
4.2. 实现读者优先算法在已有的基本解决方案的基础上，我们实现读者优先算法。
我们将通过优化访问控制的逻辑来实现读者优先的特性。
4.3. 实现写者优先算法类似地，我们在基本解决方案的基础上实现写者优先算法。
我们将调整访问控制的逻辑，使得写者优先于其他读者和写者。
4.4. 实现公平算法最后，我们实现公平算法。
我们将结合队列和条件变量等技术来确保读者和写者的访问顺序是公平的。
OS：读者写者问题(写者优先+LINUX+多线程+互斥量+代码)
OS：读者写者问题（写者优先+LINUX+多线程+互斥量+代码）⼀. 引⼦最近想⾃⼰写个简单的 WEB SERVER ，为了先练练⼿，熟悉下在LINUX系统使⽤基本的进程、线程、互斥等，就拿以前学过的 OS 问题开开⼑啦。
记得当年学读者写者问题，尤其是写者优先的时候，那是真⼼纠结啊。
刚才还觉得理解了，过⼀会⼉⼜糊涂了。
现在重新再看，还是容易纠结。
没办法，⽤得少。
我把读者优先和写者优先都实现了⼀下。
选择性重看了⼩部分《unix⾼程》使⽤了多线程+互斥量实现。
⼆. 互斥量与信号量互斥量如其名，同⼀时间只能被⼀个线程占有，实现线程间对某种数据结构的互斥访问。
试图对⼀个已经加锁的互斥量加锁，会导致线程阻塞。
允许多个线程对同⼀个互斥量加锁。
当对互斥量解锁时，阻塞在该互斥量上的线程会被唤醒，它们竞争对该互斥量加锁，加锁成功的线程将停⽌阻塞，剩余的加锁失败于是继续阻塞。
注意到，谁将竞争成功是⽆法预料的，这⼀点就类似于弱信号量。
（强信号量把阻塞在信号量上的进程按时间排队，先进先出）互斥量区别于信号量的地⽅在于，互斥量只有两种状态，锁定和⾮锁定。
它不像信号量那样可以赋值，甚⾄可以是负值。
共性⽅⾯，我所体会到的就⼀句话，都是⽤来实现互斥的。
⾄于其它区别或联系，⽤不上，不作研究。
三. 读者优先只要有⼀个读者正在读，那么后续的读者都能⽴即读，不管有多少写者在等待。
可能导致写者饥饿。
1. 读者1) 写者写时，不可读2) 有别的读者正在读，可读2. 写者1) 有读者正在读，不可写2) 有写者正在写，不可写3) ⽆读者正在读，⽆写者正在写，可写四. 写者优先当新的写者希望写时，不允许该写者后续的读者访问数据区，但必须保证之前的读者读完。
1. 读者特点1) 有写者正在写或者等待写，须等到没有写者才能读2) 没有写者，可以读2. 写者特点1) 写者与写者互斥。
当其它写者正在写时，其它写者不能写。
2) 写者与读者互斥。
之前只有读者在读，当写者出现时，必须等到之前的读者都读完才能写。
读者写者问题实验报告
北京电子科技学院（BESTI）实验报告课程：操作系统班级：0921 姓名：学号：成绩：指导教师：徐小青实验日期：2011.11.22 实验密级：/ 预习程度：代码实验时间：12:50-15:20 仪器组次：A04 必修/选修：必修实验序号：(一)实验名称：用信号量来实现读者-写者问题实验目的与要求：理解进程(或线程)及信号量的概念实验仪器：一、实验目的：理解进程(或线程)及信号量的概念二、实验内容：1、定义一个数据缓存buffer及用于实现同步互斥的信号量。
2、定义一个读者函数：●当有写者在占用buffer时，读者应该等待，直到写者不再使用该buffer。
●当有其他读者在占用buffer时，读者可对buffer进行读取操作。
●当buffer中有数据时，则从其中读取一个数据，并显示然后退出。
●当buffer中没有数据时，应等待，直到buffer中有数据可读。
3、定义一个写者函数●当有读者在占用buffer时，写者应该等待，直到所有的读者都退出为止。
●当有其他写者占用buffer时，该写者应该等待，直到占用buffer的写者退出为止。
●当buffer有空闲时，写者应该在buffer中写入一个数据并退出。
●当buffer满时，写者应该等待，直到buffer有空闲为止。
4、定义主函数，在其中可以任意创建读者与写者。
可根据用户输入创建读者或写者进程(线程)。
三、实验当堂完成内容：1，将设计好的思路以代码形式呈现，并调通。
2，将数据改变，看结果是否符合预期设想3，与同学交流，将代码完善。
四、设计思想：读进程：read(){P(Sr); 申请区域P(Scot); 锁定读者计数器first = first+1;if(first ==1)P(Sdoc);V(Scnt); 解锁读者计数器开始读；P(Scnt); 锁定读者计数器V(Sdoc);V(Scnt);V(Sr);}写进程：write(){P(sdoc);开始写;V(sdoc);}主函数设计思想：五、代码及具体解释：#include <stdlib.h>#include <windows.h>#include <stdio.h>#define P(S) WaitForSingleObject(S, INFINITE)// 这是Windows 下多线程工作的P 操作#define V(S) ReleaseSemaphore(S, 1, NULL)// 这是Windows 下多线程工作的V 操作const int RN = 5 ; // 所有读者总数（可以改变）const int WN = 3; // 所有写者总数（可以改变）HANDLE Sdoc; // 文档信号量——互斥量(临界区的信号量题目要求是1）HANDLE Sr; // 读者信号量——广义信号量（一次最多有多少个读者在读）HANDLE Scnt; // 保护g_cntReader 的互斥量（目前有多少读者正在读）int g_cntReader = 0; // 读者个数计数器// funcname : JustWait ( )// note: 显示一些信息，让后等待// ret val : void//// + Parameter :// [ int ] - nReader 读者（写者）编号，读者>0，写者<0// [ int ] - min 操作等待的最短时间// [ int ] - max 操作等待得最长时间，实际等待的时间介于两者之间// [ LPCSTR ] - info 要显示的信息void JustWait(int nReader, int min, int max, LPCSTR info);DWORD WINAPI Reader(LPVOID lpPara);DWORD WINAPI Writer(LPVOID lpPara);// 这是主函数void main(){Sdoc = CreateSemaphore(NULL, 1, 1, "Document");// 创建信号量初值，最大信号量值Sr = CreateSemaphore(NULL, 3, 3, "ReaderNumber"); // 一次最多允许3 个Scnt = CreateSemaphore(NULL, 1, 1, "ReaderCounterProtect");// 他也是一个互斥信号量，初值为 1HANDLE threads[RN+WN];for (int i=0; i<RN; i++) //不断创建读者线程threads[i] = CreateThread(0, 0, Reader, 0, 0, 0);for (int j=0; j<WN; j++)threads[j+RN] = CreateThread(0, 0, Writer, 0, 0, 0);WaitForMultipleObjects(RN+WN, threads, TRUE, INFINITE);}// 读者线程DWORD WINAPI Reader(LPVOID lpPara){// 注意是静态变量，可以使每来一个读者增加一static int reader_num = 1;int i = reader_num ++;int x=0;while (x<=5){JustWait(i, 1, 2, "我想读"); //1s的时候来，给2s的时间去读P(Sr); // 读者未满P(Scnt); // 锁定读者计数器printf("还有%d 个读者在读, 读者%d进入\n", g_cntReader, i);g_cntReader ++;if (g_cntReader == 1) // 如果是第一个读者{JustWait(i, 1, 2, "我是第一个!");P(Sdoc); // 锁定文档printf("读者%d说：有人在读，不可写文件\n", i);JustWait(i, 1, 2, "我可以读文件了！");V(Scnt); // 解锁读者计数器释放JustWait(i, 2, 5, "我在读");// 读ing…………JustWait(i, 1, 2, "我将要离开！");P(Scnt); // 锁定读者计数器g_cntReader --;if (g_cntReader == 0) // 如果是最后一个{JustWait(i, 1, 2, "我是最后一个!");printf("读者%d说：可以对文件操作了！~~~\n", i);V(Sdoc);// 解锁文档}printf("还有%d个读者在, 读者%d离开\n", g_cntReader, i);V(Scnt);// 解锁读者计数器V(Sr); // 离开JustWait(i, 5, 3, "结束");x++;printf("%d\n",x);}return 0;}DWORD WINAPI Writer(LPVOID lpPara){// 注意是静态变量，可以使每来一个写者减去一，注意初值是负值static int g_cnt = -1;int j = g_cnt --;while (1){JustWait(j, 2, 4, "我想写");// 锁定文档P(Sdoc);printf("\t写者%d说：文件正在修改不可操作\n", -j);JustWait(j, 4, 3, "写···"); // 写ing……JustWait(j, 1, 2, "写完了，离开");printf("写者%d说：可以对文件操作了\n", -j);V(Sdoc);// 解锁文档JustWait(j, 8, 4, "休息了");}return 0;}void JustWait(int nReader, int min, int max, LPCSTR info)//min为读者到来时间，max为读者离开时间{const int BASETIME = 1000;// 等待时间的基本量，以毫秒表示int wait_time = 0;// 实际等待得时间if (max==min) // 判断是为了避免%0错误，注意取随机值wait_time = min*BASETIME;//处理时间为0；elsechar s_out[128];// 最终显示的信息缓冲if (nReader > 0)// 读者大于0，写者小于0sprintf(s_out, "读者%d说: %s\n", nReader, info);elsesprintf(s_out, "\t写者%d说: %s\n", -nReader, info);printf(s_out);// 打印Sleep(wait_time);// 然后等待}//其设计思想是：读者在读，来了写着，创建写着线程，利用时间片区分他们。
读写者实验报告
《Linux系统分析》实验报告报告提交日期：姓名：程志超学号： 128355003 班级：交换生一、实验题目采用多线程互斥与同步机制，实现读者、写者问题二、实验目的掌握使用POSIX接口提供的互斥变量、条件变量实现多线程同步三、实验要求有一个文件为多个并发线程所共享，其中读线程只要求读取文件内容，写线程则要求修改文件容，允许多个线程同时读取文件内容。
但若有一个写线程在写，则其他读线程不能读；若有一个写线程在写或有其他读线程在读，则其他写线程均被拒绝。
当一个写线程正在写，而有多个读线程与写线程在等待时，写线程应优先唤醒。
读线程进去读、等待，写线程进去写、等待等状态均在屏幕上打印出来四、设计思路和流程图（对于涉及算法的实验，需要提供数据结构及其说明、测试数据的设计及测试结果分析）数据结构的说明struct prodcons{int buffer[BUFFERSIZE]; //缓冲区pthread_mutex_t lock; //互斥锁int readpos,writepos; //读写的游标pthread_cond_t notempty; //缓冲区非空条件判断pthread_cond_t notfull; //缓冲区非满条件判断};测试结果：读和写的线程交互进行五、实验体会（包括实验中遇到的问题及解决过程、产生的错误及原因分析）对线程条件变量控制相关函数pthread_cond_init()、pthread_cond_wait()和pthread_cond_signal()的原型及用法不是很了解，上网查阅相关资料，明白第一个是初始化一个条件变量，第二个等待线程，尤其要注意线程状态和条件变量的加解锁过程是/*block-->unlock-->wait() return-->lock*/六、程序清单（包括源程序、makefile、readme）/***multithread.c***/#include<stdio.h>#include<pthread.h>#define BUFFERSIZE 100#define OVER (-1)struct prodcons{int buffer[BUFFERSIZE];pthread_mutex_t lock;int readpos,writepos;pthread_cond_t notempty;pthread_cond_t notfull;};void init(struct prodcons *b){pthread_mutex_init(&b->lock,NULL);pthread_cond_init(&b->notempty,NULL);pthread_cond_init(&b->notfull,NULL);b->readpos = 0;b->writepos = 0;}void put(struct prodcons *b,int data){pthread_mutex_lock(&b->lock);if((b->writepos + 1) % BUFFERSIZE == b->readpos){ pthread_cond_wait(&b->notfull,&b->lock);}b->buffer[b->writepos] = data;b->writepos++;if(b->writepos >= BUFFERSIZE)b->writepos = 0;pthread_cond_signal(&b->notempty);pthread_mutex_unlock(&b->lock);}int get(struct prodcons *b){int data;pthread_mutex_lock(&b->lock);if(b->writepos == b->readpos){pthread_cond_wait(&b->notempty,&b->lock);}data = b->buffer[b->readpos];b->readpos++;if(b->readpos >= BUFFERSIZE)b->readpos = 0;pthread_cond_signal(&b->notfull);pthread_mutex_unlock(&b->lock);return data;}struct prodcons buffer;void *producer1(void *data){int n;for(n = 0;n < 10000;n++){//printf("%d\n",n);printf("producer1 is writing\n");put(&buffer,n);}put(&buffer,OVER);return NULL;}void *producer2(void *data){int n;for(n = 0;n < 10000;n++){//printf("%d\n",n);printf("producer2 is writing\n");put(&buffer,n);}put(&buffer,OVER);return NULL;}void *consumer1(void * data){int d;while(1){d = get(&buffer);if(d == OVER)break;//printf("%d\n",d);printf("consumer1 is reading\n");}return NULL;}void *consumer2(void * data){int d;while(1){d = get(&buffer);if(d == OVER)break;//printf("%d\n",d);printf("consumer2 is reading\n");}return NULL;}int main(void){pthread_t writer1,reader1,writer2,reader2;void *retval;init(&buffer);pthread_create(&writer1,NULL,producer1,0);pthread_create(&reader1,NULL,consumer1,0);pthread_create(&writer2,NULL,producer2,0);pthread_create(&reader2,NULL,consumer2,0);pthread_join(writer1,&retval);pthread_join(reader1,&retval);pthread_join(writer2,&retval);pthread_join(reader2,&retval);return 0;}。
读者写者问题实验报告
读者写者问题实验报告引言读者写者问题是计算机科学中经典的同步问题之一，它涉及多线程编程中的资源竞争与同步机制。
通过对读者写者问题的研究，我们可以深入理解线程同步的重要性，并掌握解决并发编程中可能出现的竞争条件和死锁等问题的方法。
在本实验中，我们将设计并实现一个简单的读者写者问题的解决方案，并通过模拟多个读者和写者的并发访问来验证方案的正确性和效果。
问题描述读者写者问题可描述为：有一共享资源（如文件、数据库等），读者可同时访问共享资源进行读取操作，但写者在进行写入操作时，不可同时被其他任何读者或写者访问。
读者和写者的并发访问需要由线程同步机制来保证共享资源的一致性和完整性。
实验设计与实现为了解决读者写者问题，我们需要考虑以下几个关键点：1. 共享资源的访问控制我们可以使用互斥量（Mutex）来实现对共享资源的访问控制。
当一个线程访问共享资源时，它需要先获得互斥量的锁，如果锁已被其他线程占用，则线程进入等待状态，直到锁可用。
一旦线程完成对共享资源的访问，它将释放锁，以便其他线程继续访问。
2. 读者与写者的优先级在读者写者问题中，我们往往需要设定某个优先级规则，以确定读者和写者之间的调度顺序。
一种常见的策略是给予写者优先级，即当一个写者在等待访问共享资源时，其他读者都必须等待。
这样做是为了避免写者长时间等待，以免造成饥饿问题。
3. 记录读者和写者的数量为了控制读者和写者的并发访问，我们需要记录当前同时访问共享资源的读者和写者的数量。
我们可以使用整数变量来记录读者和写者的数量，并通过信号量来保证对这些计数变量的互斥访问。
4. 同步机制的设计在实现读者写者问题的解决方案时，我们需要考虑如何合理地使用互斥量和信号量，并结合优先级规则来实现读者和写者的同步。
这需要通过仔细的设计和调试来确保解决方案的正确性。
实验结果与分析我们基于上述设计实现了一个读者写者问题的解决方案，并进行了多次仿真实验。
实验环境•操作系统：Windows 10•编程语言：C++•编译器：GCC实验步骤1.编写读者和写者线程的代码，其中涉及到对共享资源的读取和写入操作，以及对计数变量和互斥量的访问操作。
在linux下实现读者写者问题源代码
在linux下实现读者写者问题源代码读者写者问题是计算机科学中的一个经典同步问题，用于描述多个读者和写者对共享资源的访问。
在这个问题中，多个读者可以同时读取共享资源，但是写者在写入共享资源时必须独占访问。
在Linux下，我们可以使用线程和互斥锁来实现读者写者问题。
下面是一个简单的源代码示例：```c#include <stdio.h>#include <stdlib.h>#include <pthread.h>#define READERS_COUNT 5#define WRITERS_COUNT 2pthread_mutex_t mutex;pthread_cond_t cond_reader, cond_writer;int readers = 0;int writers = 0;void *reader(void *arg) {int id = *(int *)arg;while (1) {pthread_mutex_lock(&mutex);while (writers > 0) {pthread_cond_wait(&cond_reader, &mutex); }readers++;pthread_mutex_unlock(&mutex);// 读取共享资源printf("Reader %d is reading\n", id);pthread_mutex_lock(&mutex);readers--;if (readers == 0) {pthread_cond_signal(&cond_writer);}pthread_mutex_unlock(&mutex);}pthread_exit(NULL);}void *writer(void *arg) {int id = *(int *)arg;while (1) {pthread_mutex_lock(&mutex);while (readers > 0 || writers > 0) {pthread_cond_wait(&cond_writer, &mutex); }writers++;pthread_mutex_unlock(&mutex);// 写入共享资源printf("Writer %d is writing\n", id);pthread_mutex_lock(&mutex);writers--;pthread_cond_signal(&cond_writer);pthread_cond_broadcast(&cond_reader);pthread_mutex_unlock(&mutex);}pthread_exit(NULL);}int main() {pthread_t readers[READERS_COUNT];pthread_t writers[WRITERS_COUNT];int reader_ids[READERS_COUNT];int writer_ids[WRITERS_COUNT];pthread_mutex_init(&mutex, NULL);pthread_cond_init(&cond_reader, NULL);pthread_cond_init(&cond_writer, NULL);// 创建读者线程for (int i = 0; i < READERS_COUNT; i++) {reader_ids[i] = i + 1;pthread_create(&readers[i], NULL, reader, &reader_ids[i]); }// 创建写者线程for (int i = 0; i < WRITERS_COUNT; i++) {writer_ids[i] = i + 1;pthread_create(&writers[i], NULL, writer, &writer_ids[i]); }// 等待线程结束for (int i = 0; i < READERS_COUNT; i++) {pthread_join(readers[i], NULL);}for (int i = 0; i < WRITERS_COUNT; i++) {pthread_join(writers[i], NULL);}pthread_mutex_destroy(&mutex);pthread_cond_destroy(&cond_reader);pthread_cond_destroy(&cond_writer);return 0;}```在这个源代码中，我们使用了互斥锁（`pthread_mutex_t`）和条件变量（`pthread_cond_t`）来实现读者写者问题的同步。
操作系统读者写者实验报告
操作系统读者写者实验报告一、实验目的通过实验理解读者写者问题的实现原理，掌握相关的同步机制，实现读者写者问题的经典解法，并对比不同解法的优缺点。
二、实验原理1.读者写者问题读者写者问题是指在多个线程同时读写一个共享数据的情况下可能出现的问题。
其问题的核心在于多个读线程可以同时读，但只能有一个写线程能够写，并且在写操作过程中不能有任何的读操作。
2.互斥与同步为了解决读者写者问题，在多线程并发读写共享数据时，需要使用互斥与同步机制来保证数据的完整性和一致性。
-互斥：通过锁机制来保证只允许一个线程进入临界区，其他线程需要等待锁的释放。
-同步：通过信号量等机制来保证线程按照一定顺序执行。
三、实验步骤本次实验中将实现两个版本的读者写者问题解决方案：一是使用互斥锁和条件变量，二是使用信号量。
1.使用互斥锁和条件变量（1）定义全局变量和互斥锁：共享数据、读者数目、互斥锁、写者条件变量、读者条件变量。
（2）初始化互斥锁和条件变量。
（3）写者线程的实现：获取互斥锁，判断当前是否有读者或写者，如果有则等待条件变量，然后进行写操作，释放互斥锁。
（4）读者线程的实现：获取互斥锁，判断是否有写者，如果有则等待条件变量，否则增加读者数目并释放互斥锁，进行读操作。
（5）测试程序的运行并输出结果。
2.使用信号量（1）定义全局变量和信号量：共享数据、读者信号量、写者信号量、用于保护读者数目和写者数目的互斥信号量。
（2）初始化信号量和互斥信号量。
（3）写者线程的实现：首先获取写者互斥信号量，然后获取写者信号量，进行写操作，释放写者信号量和写者互斥信号量。
（4）读者线程的实现：首先获取读者互斥信号量，然后增加读者数目，如果是第一个读者则获取写者信号量，然后进行读操作，释放读者信号量和读者互斥信号量，如果是最后一个读者则释放写者信号量。
（5）测试程序的运行并输出结果。
四、实验结果与分析通过对比两种解决方案，可以得出以下结论：1.使用互斥锁和条件变量的解决方案相对较为简单，但可能存在饥饿问题，即可能会导致一些线程一直无法访问共享资源。
操作系统读者写者实验报告
《操作系统原理》课程设计课程设计起止时间：2009年11月30日至12月11日指导教师：成绩：课程设计成绩评定表一．设计说明（四号，宋体，加粗）通过学习操作系统，与之前的语句基础相结合，用C语言来编写读者写着问题。
读者写者问题（read—write problem）是一个经典的并发程序设计问题。
有两组并发进程：读者和写者，共享一个问题F，要求：（1）允许多个读者可同时对之执行读操作；（2）只允许一个写者往文件中写信息；（3）任一写者在完成写操作之前不允许其他读者或者写者工作；（4）写者执行写操作前，应让已有的写者和读者全部退出。
二．工作原理（四号，宋体，加粗）读者和写者问题是典型是经典的进程同步问题，进程同步任务是使并发的诸进程之间有效的共享资源，相互合作，从而保证程序的可再现性。
在读者—写者问题中，允许多个读者同时读一个数据对象，因为读文件不会使数据发生混乱，但绝不允许一个写者进程与其他读者进程或写者进程同时访问该数据对象。
文件是诸进程能互斥访问临界资源，读者进程和写者进程，写者进程和写者进程之间的互斥。
在读者进程中，可以有多个读者在读数据库，在读者进程的计数要互斥，以免发生错误，同时注意当第一个读者进程读时，一定要封锁写者进程。
当读者进程逐渐撤离时，也要针对计数变量进行互斥操作，若当前为最后一个读者进程时，读完后，则唤醒写者进程。
当写者进程在进行写操作时，可以封锁其他读者或写者进程，当写操作完成时，唤醒其他读者或写者进程。
所以分析了以下4种可能发生的情况：第 1 种情况: 读者的优先权比写者高，而且，不用调配。
所有读者的优先权都比写者的优先权高，而且，不用调配。
一个读者需要等待的唯一情况是，一个写者已经占用了文件。
一个写者可以取得文件的条件是，没有一个读者处在等待状态或正在读文件。
允许读者们结盟，以便能长期占用文件，而禁止写者的写。
第 2 种情况: 在一个读者已经占有了文件的时候，全体读者的优先权才比写者高。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
计算机科学与技术系
实验（项目）报告
一、基本信息
二、目的与要求
目的：
通过实验掌握Linux环境下多线程程序的开发方法。
要求：
1.掌握线程的基本概念及操作；
2.掌握线程间通信的基本方法；
3.掌握Linux环境下多线程程序的开发方法及步骤。
三、完成实验（项目）过程和效果
内容：
1.问题分析；
有100个读线程和100个写线程共同读、写文件
(1)允许多个reader同时读一个文件；
(2)当有一个reader在读文件时，不允许writer写文件；
(3)当有一个writer在写文件时，不允许reader读文件，也不允许其
他writer写文件。
2.程序实现；
3.程序的调试与运行。
步骤：
1.问题分析
可以利用读写锁解决读者-写者问题
2.程序实现
1)读者：
void *Reader(void *id)
{
RandomSleep();
pthread_rwlock_rdlock(&rwlock);
ReaderNum++;
ReadFile(*((int *)id));
ReaderNum--;
pthread_rwlock_unlock(&rwlock); }
2)写者：
void *Writer(void *id)
{
RandomSleep();
pthread_rwlock_wrlock(&rwlock);
WriterNum++;
WriteFile(*((int *)id));
WriterNum--;
pthread_rwlock_unlock(&rwlock);
}
3)线程的创建：
for(i=0; i<NUM; i++)
{
id[i] = i;
pthread_create(&readthread[i], NULL, Reader, (void *)&id[i]);
pthread_create(&writethread[i], NULL, Writer, (void *)&id[i]);
}
for(i=0; i<NUM; i++)
{
pthread_join(readthread[i], NULL);
pthread_join(writethread[i], NULL);
}
3.程序的调试与运行
四、知识应用以及经验总结
1.线程与进程的区别？
（1）一个程序至少有一个进程,一个进程至少有一个线程。
（2）线程的划分尺度小于进程，使得多线程程序的并发性高。
（3）进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；进程正相反。
一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行。