操作系统实验报告
姓名：ＸＸＸ
学号：20111230100Ｘ
年级：2011 级
专业：计算机科学与技术（应用型）指导教师：黄玲
1.实验目的
理解死锁，理解死锁的预防，理解Linux线程控制。
2.实验环境
Ubuntu 8.0
3.实验内容
3.1 Linux线程说明
Linux的线程有两种，一种内核线程，一种用户线程。通常使用pthread线程库管理用户线程。线程管理库专门为每一个进程构造一个管理线程，负责处理线程相关的管理工作。当进程第一次调用pthread_create()创建一个线程时，就会创建并启动管理线程。
（1）创建线程
int pthread_create(pthread_t restrict tidp,const pthread_attr_t *restrict attr,void*(*start_rtn)(void),void *restrict arg)
tidp为指向线程标识符的指针，attr为线程属性，start_rtn为线程执行函数，arg为其参数。（2）线程互斥信号量（用于临界资源访问）的创建及其初始化
int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *mutexattr)
mutex为指向互斥信号量的指针，mutexattr为信号量属性。
（3）线程互斥信号量的申请
int pthread_mutex_lock(pthread_mutex_t *mutex)
mutex为指向互斥信号量的指针
（4）线程互斥信号量的释放
int pthread_mutex_unlock(pthread_mutex_t *mutex)
(5) 编译包含pthread线程的源程序，要加上-lpthread ,因为pthread库不是Linux系统库。如：
gcc –o mycode mycode.c -lpthread
3.2 实验要求：下面实例可能会发生死锁。要求修改实例，预防死锁发生。
本程序模拟十字路口汽车交通状况。道路见下图，有四段路A、B、C、D，每段路一次只允许一辆车通过。
南
C
东西
B D
A
北
实验代码：
#include
#include
#include
#include
#define Max 7
pthread_t E[Max];//从东方来的汽车。每辆汽车对应一个线程。pthread_t W[Max];//从西方来的汽车
pthread_t S[Max];//从南方来的汽车
pthread_mutex_t s1;//线程互斥信号量，对应C路段
pthread_mutex_t s2; //线程互斥信号量，对应B路段
pthread_mutex_t s3; //线程互斥信号量，对应A路段
pthread_mutex_t s4; //线程互斥信号量，对应D路段
int i; void *s(void *a1) //南边来的汽车的线程执行体
{
int serialNum=*((int*)a1);//取当前汽车序号
pthread_mutex_lock(&s1);
printf("S %d enter C\n",serialNum);
sleep(2);
pthread_mutex_unlock(&s1);
pthread_mutex_lock(&s2);
printf("S %d enter B\n",serialNum);
sleep(2);
pthread_mutex_unlock(&s2);
pthread_mutex_lock(&s3);
printf("S %d enter A\n",serialNum);
sleep(2);
printf("S %d leave A\n",serialNum);
printf("!!!S finished one\n");
sleep(2);
pthread_mutex_unlock(&s3);
}
void *e(void *a2) //东边来的汽车
{
int serialNum=*((int*)a2);
pthread_mutex_lock(&s2);
printf("E %d enter B\n",serialNum); sleep(2);
pthread_mutex_unlock(&s2);
pthread_mutex_lock(&s3);
printf("E %d enter A\n",serialNum); sleep(2);
pthread_mutex_unlock(&s3);
pthread_mutex_lock(&s4);
printf("E %d enter D\n",serialNum); sleep(2);
printf("E %d leave D\n",serialNum); printf("!!!E finished one \n");
sleep(2);
pthread_mutex_unlock(&s4);
}
void *w(void *a3) //西边来的汽车
{
int serialNum=*((int*)a3);
pthread_mutex_lock(&s4);
printf("W %d enter D\n",serialNum); sleep(2);
pthread_mutex_unlock(&s4);
pthread_mutex_lock(&s1);
printf("W %d enter C\n",serialNum); sleep(2);
printf("W %d leave C\n",serialNum); printf("!!!W finished one \n");
sleep(2);
pthread_mutex_unlock(&s1);
}
int main(int argc,char *argv[])
{
int c;
printf("Please input the integer number,less than 7: ");//车流量
scanf("%d",&c);
if( c > Max )
{
printf("You enter the wrong number,try again.\n");
exit(1);
}
int i1 = pthread_mutex_init(&s1,NULL); //线程互斥信号量创建及初始化 if(i1 != 0)
{
printf("Create error.");
exit(1);
}
int i2 = pthread_mutex_init(&s2,NULL);
if(i2 != 0)
{
printf("Create error.");
exit(1);
}
int i3 = pthread_mutex_init(&s3,NULL);
if(i3 != 0)
{
printf("Create error.");
exit(1);
}
int i4 = pthread_mutex_init(&s4,NULL);
if(i4 != 0)
{
printf("Create error.");
exit(1);
}
for(i = 1;i <= c; i++)
{
int* iaddr=&i;//汽车序号
pthread_create(&W[i-1],NULL,(void *)w,(void *)iaddr);//创建线程 pthread_create(&E[i-1],NULL,(void *)e,(void *)iaddr);
pthread_create(&S[i-1],NULL,(void *)s,(void *)iaddr);
sleep(5);
}
for(i = 0; i < c; i++)
{
pthread_join(W[i],NULL);//当前线程等待W[i]线程终止
pthread_join(E[i],NULL);
pthread_join(S[i],NULL);
}
exit(0); //main进程结束
}
实验截图：
实验总结：通过本次实验，更进一步认识死锁的发生条件和预防死锁发生的方法，线程的种类，和线程创建及管理机制。死锁发生的条件有互斥条件，占有且等待条件，不可抢占条件等。我们只要破坏死锁发生条件之一我们就可以预防死锁的发生！本实验采用破坏占有且等待条件预防死锁发生！
Sqlcode -244 死锁问题解决 版本说明 事件日期作者说明 创建09年4月16日Alan 创建文档 一、分析产生死锁的原因 这个问题通常是因为锁表产生的。要么是多个用户同时访问数据库导致该问题，要么是因为某个进程死了以后资源未释放导致的。 如果是前一种情况，可以考虑将数据库表的锁级别改为行锁，来减少撞锁的机会；或在应用程序中，用set lock mode wait 3这样的语句，在撞锁后等待若干秒重试。 如果是后一种情况，可以在数据库端用onstat -g ses/onstat -g sql/onstat -k等命令找出锁表的进程，用onmode -z命令结束进程；如果不行，就需要重新启动数据库来释放资源。 二、方法一 onmode -u 将数据库服务器强行进入单用户模式，来释放被锁的表。注意：生产环境不适合。 三、方法二 1、onstat -k |grep HDR+X 说明：HDR+X为排他锁，HDR 头，X 互斥。返回信息里面的owner项是正持有锁的线程的共享内存地址。 2、onstat -u |grep c60a363c 说明：c60a363c为1中查到的owner内容。sessid是会话标识符编号。 3、onstat -g ses 20287 说明：20287为2中查到的sessid内容。Pid为与此会话的前端关联的进程标识符。 4、onstat -g sql 20287
说明：20287为2中查到的sessid内容。通过上面的命令可以查看执行的sql语句。 5、ps -ef |grep 409918 说明：409918为4中查到的pid内容。由此，我们可以得到锁表的进程。可以根据锁表进程的重要程度采取相应的处理方法。对于重要且该进程可以自动重联数据库的进程，可以用onmode -z sessid的方法杀掉锁表session。否则也可以直接杀掉锁表的进程 kill -9 pid。 四、避免锁表频繁发生的方法 4.1将页锁改为行锁 1、执行下面sql语句可以查询当前库中所有为页锁的表名： select tabname from systables where locklevel='P' and tabid > 99 2、执行下面语句将页锁改为行锁 alter table tabname lock mode(row) 4.2统计更新 UPDATE STATISTICS; 4.3修改数据库配置onconfig OPTCOMPIND参数帮助优化程序为应用选择合适的访问方法。 ?如果OPTCOMPIND等于0，优化程序给予现存索引优先权，即使在表扫描比较快时。 ?如果OPTCOMPIND设置为1，给定查询的隔离级设置为Repeatable Read时，优化程序才使用索引。 ?如果OPTCOMPIND等于2，优化程序选择基于开销选择查询方式。，即使表扫描可以临时锁定整个表。 *建议设置：OPTCOMPIND 0 # To hint the optimizer 五、起停informix数据库 停掉informix数据库 onmode -ky 启动informix数据库 oninit 注意千万别加-i参数，这样会初始化表空间，造成数据完全丢失且无法挽回。
红河学院 课程设计报告 操作系统 课程名称： 6个哲学家进餐 设计题目： 院系：工学院 专业：计算机科学与技术班级：11计科班 曹永前 设计者： 学号：201101030466 指导教师：韦相 2013 年 5 月26 日
1. 问题描述： 一个房间内有6个哲学家，他们的生活就是思考和进食。哲学家思考后，过一定的时间就会饥饿，饥饿之后就想吃饭，吃饭后再思考。房间里有一张圆桌，桌子周围放有五把椅子，分别属于五位哲学家每两位哲学家之间有一把叉子，哲学家进食时必须同时使用左右两把叉子。 2. 问题分析 1、写出哲学家进餐的算法描述。 用六只筷子解决需要用两双筷子来进餐的六个哲学家,由于每个哲学家都需要其周围的两只筷子,所以筷子是公用信号量,这久需要设置一个互斥信号量,来使六个哲学家互斥的进餐.具体做法将六个信号量设置为0-5,用pv 源于来控制信号量,并将六个哲学家分别编号为0-5.经过仔细分析我们会发现,有这样一个问题存在,就是当每个哲学家都申请到他周围的一只筷子时,由于他们每人都只有一只筷子无法进餐,没有进餐他们就无法释放他们已经得得到的筷子,这样是进餐出于一种僵局,无法继续下去,这就是死锁问题. 2、死锁问题的分析与具体的解决方法。 死锁问题就是当每个哲学家都拿到且只拿到一只筷子, 这样每个哲学家都无
法进餐,也无法释放所得到的筷子,所以解决死锁我们就要从这入手,就是怎样去预防使所有哲学家不要同时去申请他们同一方向的筷子.根据这解决死锁的方法有以下几种: a.每一次最多只能有五个哲学家申请进餐.这样其中的一个哲学家就能申请 到两只筷子,就能够进餐,再将筷子释放给其他哲学家进餐. b.用AND信号量,就是哲学家需同时申请其左右两边的筷子,两边都有资源的 时候,才能让这个哲学家得到资源,这样哲学家只要申请到筷子就能进餐, 再将筷子释放给其他哲学家进餐. c.用管程机制来实现。 d.我们前面已经将每个哲学家都分配了一个编号,我们可以编号为奇数的哲 学家首先去申请其左边的筷子,再去申请其右手边的筷子;让编号为偶数的哲学家,先去申请其右边的筷子,再去申请其左边的筷子.我们可以看出编号为奇数的哲学家左边,与编号为偶数的哲学家的右边为同一只筷子,当其中一个哲学家拿到此筷子后,他另一边的筷子也是空闲的,这样就能避免死锁. 主程序中我使用的是最后一种避免死锁的方法. 3、用C程序实现哲学家进餐。（注：可以使用共享变量的方式，也可以使用信 号量的方式或其他方法来实现） 3.程序清单 #include 死锁练习题 (一)单项选择题 l系统出现死锁的根本原因是( )。A．作业调度不当B．系统中进程太多C．资源的独占性D．资源管理和进程推进顺序都不得当 2．死锁的防止是根据( )采取措施实现的。A．配置足够的系统资源B．使进程的推进顺序合理C．破坏产生死锁的四个必要条件之一D．防止系统进入不安全状态 3．采用按序分配资源的策略可以防止死锁．这是利用了使( )条件不成立。A．互斥使用资源B循环等待资源c．不可抢夺资源D．占有并等待资源 4．可抢夺的资源分配策略可预防死锁，但它只适用于( )。A．打印机B．磁带机c．绘图仪D．主存空间和处理器 5．进程调度算法中的( )属于抢夺式的分配处理器的策略。A．时间片轮转算法B．非抢占式优先数算法c．先来先服务算法D．分级调度算法 6．用银行家算法避免死锁时，检测到( )时才分配资源。A．进程首次申请资源时对资源的最大需求量超过系统现存的资源量B．进程己占用的资源数与本次申请资源数之和超过对资源的最大需求量c．进程已占用的资源数与本次申请的资源数之和不超过对资源的最大需求量，且现存资源能满足尚需的最大资源量D进程已占用的资源数与本次申请的资源数 之和不超过对资源的最大需求量，且现存资源能满足本次申请量，但不能满足尚需的最大资源量 7．实际的操作系统要兼顾资源的使用效率和安全可靠，对资源的分配策略，往往采用( )策略。A死锁的防止B．死锁的避免c．死锁的检测D．死锁的防止、避免和检测的混合(二)填空题 l若系统中存在一种进程，它们中的每一个进程都占有了某种资源而又都在等待其中另一个进程所占用的资源。这种等待永远不能结束,则说明出现了______。2．如果操作系统对 ______或没有顾及进程______可能出现的情况，则就可能形成死锁。3．系统出现死锁的四 主线程A等待另一个线程B的完成才能继续，在线程B中又要更新主线程A的界面，这里涉及了同步问题以及由此可能产生的死锁问题，同步问题在修改后的文章中讲得比较清楚了，对于线程之间可能产生死锁的浅析如下： 在等待线程B中更新主线程A的界面，如果未能正确处理A,B两线程同步的问题，极有可能导致两线程间的死锁 C#线程同步与死锁 在上一讲介绍了使用lock来实现C#线程同步。实际上，这个lock是C#的一个障眼法，在C#编译器编译lock语句时，将其编译成了调用Monitor类。先看看下面的C#源代码： 1.public static void MyLock() 2.{ 3.lock (typeof(Program)) 4. { 5. } 6.} 7. 上面的代码通过lock语句使MyLock同步，这个方法被编译成IL后，代码如图1所示。 图1 从上图被标注的区域可以看到，一条lock语句被编译成了调用Monitor的Enter和Exit方法。Monitor 在System.Threading命名空间中。lock的功能就相当于直接调用Monitor的Entry方法，所不同的是，lock方法在结束后，会自动解除锁定，当然，在IL中是调用了Monitor的Exit方法，但在C#程序中，看起来是自动解锁的，这类似于C#中的using语句，可以自动释放数据库等的资源。但如果直接在C#源程序中使用Monitor类，就必须调用Exit方法来显式地解除锁定。如下面的代码所示： 1.Monitor.Entry(lockObj); 2.try 3.{ 4.// lockObj的同布区 5.} 6.catch(Exception e) 7.{ 8.// 异常处理代码 9.} 10.finally 11.{ 12. Monitor.Exit(lockObj); // 解除锁定 第6章死锁-习题集 一、选择题 1. C 2. C 3. C 4. C //产生死锁的原因是系统资源不足及进程推进顺序不正确 5. B 6. D 7. B 8. C 9. C 10. D //有序资源分配法的实现思想是将系统中的所有资源都按类型赋予一个编号（如打 印机1，磁带机为2等），要求每一个进程均严格按照编号递增的次序来申请资源，同类资源一次申请完。这样不会造成循环等待。 11. A //互斥条件是资源本身固有的特性。 12. B //当每个都获得2台打印机且系统中剩余打印机不少于1台时，系统不会发生死锁， 即11-2N>=1，由此知N<=5。 //本注： N=1，空闲11-3*1=8，不死锁 N=2，空闲11-3*2=5，不死锁 N=3，空闲11-3*3=2，不死锁 N=4，每个2台，空闲11-2*4=3，不死锁 N=5，每个2台，空闲11-2*5=1，不死锁 N=6，5个进程2台，1个进程1台，无空闲，死锁！ 13. C //同上例。8-2K>=1，K<=3.5，向上取整为4。 14. B 15. B 16. B //本注：破坏了死锁必要条件“环循等待”，属于“死锁预防” 17. C 18. D //本注：P2和P3无法满足资源需要，都需资源R2三个。 二、综合应用题 1.所谓死锁是指多个进程因竞争系统资源或相互通信而处于永久阻塞状态，若无外力作 用，这些进程都将无法向前推进。 产生死锁的原因是：一是由多进程共享的资源不足而引起竞争资源；二是由于进程在运行过程中具有异步性，进程推进顺序非法。 2.必要条件如下： ●互斥条件。指在一段时间内某资源仅为一个进程所占有。 ●不剥夺条件。指进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走， 而只能由该进程自己释放。 ●部分已分配条件(Hold and Wait)：指进程每次申请它所需要的一部分资源，在等待 分配新资源的同时，进程继续占有已分配到的资源。 ●环路等待条件。指存在一种进程资源的循环等待链，链中每一个进程已获得的资源 同时被链中下一个进程所请求。 解决死锁问题常采用的措施有： ●死锁预防。通过破坏死锁产生的四个必要条件中之一来预防死锁的发生。 ●死锁避免。在资源动态分配进程中，用某种方法防止系统进程不安全状态，从而避 免死锁。 ●死锁的检测及解除。通过系统的检测机构及时地检测出死锁的发生，然后采取某种 措施解除死锁。 3.有可能。例如在系统死锁的状态下，进程处于占有等待资源的状态，应当即不属于运行 态也不属于就绪态，即都处于阻塞状态时。 4.在资源分配系统中，死锁发生的原因是由于多个进程共享有限的独占型资源。当多个进 程占有了部分资源又需要更多的资源时，就可能形成循环等待链而导致死锁。 死锁情况分析：每个进程都占有W-1个资源，需再分配1个资源，为保证不死锁，系统必须至少有一个可分配的资源，取M满足： M>=N(W-1)+1 因此保证系统不发生死锁的最小M什可以从下面公式获得： M=N(W-1)+1 1)2*0+1=1，而M=3，不会死锁 2)2*1+1=3，而M=3，不会死锁 3)2*2+1=5，而M=3，可能死锁。出现死锁情况是：一个进程占有2个资源，另一占 1个资源 4)3*1+1=4，而M=5，不会死锁 5)3*2+1=7，而M=7，可能死锁。出现死锁情况是：3个进程各占2个资源 死锁习题 一、填空题 2．死锁产生的原因是。 3．产生死锁的四个必要条件是、、、。 二、单项选择题 1．两个进程争夺同一个资源。 （A）一定死锁（B）不一定死锁 （C）不死锁（D）以上说法都不对 4．如果发现系统有的进程队 列就说明系统有可能发生死锁了。 （A）互斥（B）可剥夺 （C）循环等待（D）同步 5．预先静态分配法是通过破坏条件，来达到预防死锁目的的。 （A）互斥使用资源/循环等待资源 （B）非抢占式分配/互斥使用资源 （C) 占有且等待资源/循环等待资源 （D）循环等待资源/互斥使用资源 7．下列关于死锁的说法中，正确的是？ 1）有环必死锁; 2）死锁必有环; 3）有环无死锁; 4）死锁也无环 8．资源有序分配法的目的是？ 1）死锁预防; 2）死锁避免; 3）死锁检测; 4）死锁解除 8．死锁的预防方法中，不太可能的一种方法使（）。 A 摈弃互斥条件 B 摈弃请求和保持条件 C 摈弃不剥夺条件 D 摈弃环路等待条件 10. 资源的按序分配策略可以破坏（）条件。 A 互斥使用资源 B 占有且等待资源 C 不可剥夺资源 D 环路等待资源 三、多项选择题 1．造成死锁的原因是_________。 （A）内存容量太小（B）系统进程数量太多，系统资源分配不当 （C）CPU速度太慢（D）进程推进顺序不合适 （E）外存容量太小 2．下列叙述正确的是_________。 （A）对临界资源应采取互斥访问方式来实现共享 （B）进程的并发执行会破坏程序的“封 闭性” （C）进程的并发执行会破坏程序的“可再现性” （D）进程的并发执行就是多个进程同时占有CPU （E）系统死锁就是程序处于死循环3．通常不采用_________方法来解除死锁。 （A）终止一个死锁进程（B）终止所有死锁进程 （C）从死锁进程处抢夺资源（D）从非死锁进程处抢夺资源 （E）终止系统所有进程 5．通常使用的死锁防止策略有_________。 （A）动态分配资源（B）静态分配资源 （C）按序分配资源（D）非剥夺式分配资源 （E）剥夺式分配资源 四、名词解释 1死锁 第五章死锁练习题 (一)单项选择题 1．系统出现死锁的根本原因是( )。 A．作业调度不当B．系统中进程太多C．资源的独占性D．资源管理和进程推进顺序都不得当 2．死锁的防止是根据( )采取措施实现的。 A．配置足够的系统资源B．使进程的推进顺序合理 C．破坏产生死锁的四个必要条件之一D．防止系统进入不安全状态 3．采用按序分配资源的策略可以防止死锁．这是利用了使( )条件不成立。 A．互斥使用资源B循环等待资源C．不可抢夺资源D．占有并等待资源 4．可抢夺的资源分配策略可预防死锁，但它只适用于( )。 A．打印机B．磁带机C．绘图仪D．主存空间和处理器 5．进程调度算法中的( )属于抢夺式的分配处理器的策略。 A．时间片轮转算法B．非抢占式优先数算法C．先来先服务算法D．分级调度算法 6．用银行家算法避免死锁时，检测到( )时才分配资源。 A．进程首次申请资源时对资源的最大需求量超过系统现存的资源量 B．进程己占用的资源数与本次申请资源数之和超过对资源的最大需求量 C．进程已占用的资源数与本次申请的资源数之和不超过对资源的最大需求量，且现存资源能满足尚需的最大资源量 D进程已占用的资源数与本次申请的资源数之和不超过对资源的最大需求量，且现存资源能满足本次申请量，但不能满足尚需的最大资源量 7．实际的操作系统要兼顾资源的使用效率和安全可靠，对资源的分配策略，往往采用( )策略。 A死锁的防止B．死锁的避免C．死锁的检测D．死锁的防止、避免和检测的混合 (二)填空题 1．若系统中存在一种进程，它们中的每一个进程都占有了某种资源而又都在等待其中另一个进程所占用的资源。这种等待永远不能结束,则说明出现了______。 2．如果操作系统对______或没有顾及进程______可能出现的情况，则就可能形成死锁。 3．系统出现死锁的四个必要条件是：互斥使用资源，______，不可抢夺资源和______。 4．如果进程申请一个某类资源时，可以把该类资源中的任意一个空闲资源分配给进程，则说该类资源中的所有资源是______。 5．如果资源分配图中无环路，则系统中______发生。 6．为了防止死锁的发生，只要采用分配策略使四个必要条件中的______。 7．使占有并等待资源的条件不成立而防止死锁常用两种方法：______和______. 8静态分配资源也称______，要求每—个进程在______就申请它需要的全部资源。 9．释放已占资源的分配策略是仅当进程______时才允许它去申请资源。 10．抢夺式分配资源约定，如果一个进程已经占有了某些资源又要申请新资源，而新资源不能满足必须等待时、系统可以______该进程已占有的资源。 11．目前抢夺式的分配策略只适用于______和______。 12．对资源采用______的策略可以使循环等待资源的条件不成立。 13．如果操作系统能保证所有的进程在有限的时间内得到需要的全部资源，则称系统处于______。14．只要能保持系统处于安全状态就可______的发生。 15．______是一种古典的安全状态测试方法。 16．要实现______，只要当进程提出资源申请时，系统动态测试资源分配情况，仅当能确保系统安全时才把资源分配给进程。 并发危险 解决多线程代码中的11 个常见的问题 Joe Duffy 本文将介绍以下内容：?基本并发概念 ?并发问题和抑制措施 ?实现安全性的模式?横切概念本文使用了以下技术： 多线程、.NET Framework 目录 数据争用 忘记同步 粒度错误 读写撕裂 无锁定重新排序 重新进入 死锁 锁保护 戳记 两步舞曲 优先级反转 实现安全性的模式 不变性 纯度 隔离 并发现象无处不在。服务器端程序长久以来都必须负责处理基本并发编程模型，而随着多核处理器的日益普及，客户端程序也将需要执行一些任务。随着并发操作的不断增加，有关确保安全的问题也浮现出来。也就是说，在面对大量逻辑并发操作和不断变化的物理硬件并行性程度时，程序必须继续保持同样级别的稳定性和可靠性。 与对应的顺序代码相比，正确设计的并发代码还必须遵循一些额外的规则。对内存的读写以及对共享资源的访问必须使用同步机制进行管制，以防发生冲突。另外，通常有必要对线程进行协调以协同完成某项工作。 这些附加要求所产生的直接结果是，可以从根本上确保线程始终保持一致并且保证其顺利向前推进。同步和协调对时间的依赖性很强，这就导致了它们具有不确定性，难于进行预测和测试。 这些属性之所以让人觉得有些困难，只是因为人们的思路还未转变过来。没有可供学习的专门API，也没有可进行复制和粘贴的代码段。实际上的确有一组基础概念需要您学习和适应。很可能随着时间的推移某些语言和库会隐藏一些概念，但如果您现在就开始执行并发操作，则不会遇到这种情况。本 文将介绍需要注意的一些较为常见的挑战，并针对您在软件中如何运用它们给出一些建议。 首先我将讨论在并发程序中经常会出错的一类问题。我把它们称为“安全隐患”，因为它们很容易发现并且后果通常比较严重。这些危险会导致您的程序因崩溃或内存问题而中断。 当从多个线程并发访问数据时会发生数据争用（或竞争条件）。特别是，在一个或多个线程写入一段数据的同时，如果有一个或多个线程也在读取这段数据，则会发生这种情况。之所以会出现这种问题，是因为Windows 程序（如C++ 和Microsoft .NET Framework 之类的程序）基本上都基于共享内存概念，进程中的所有线程均可访问驻留在同一虚拟地址空间中的数据。静态变量和堆分配可用于共享。请考虑下面这个典型的例子： static class Counter { internal static int s_curr = 0; internal static int GetNext() { return s_curr++; } } Counter 的目标可能是想为GetNext 的每个调用分发一个新的唯一数字。但是，如果程序中的两个线程同时调用GetNext，则这两个线程可能被赋予相同的数字。原因是s_curr++ 编译包括三个独立的步骤： 1.将当前值从共享的s_curr 变量读入处理器寄存器。 2.递增该寄存器。 3.将寄存器值重新写入共享s_curr 变量。 按照这种顺序执行的两个线程可能会在本地从s_curr 读取了相同的值（比如42）并将其递增到某个值（比如43），然后发布相同的结果值。这样一来，GetNext 将为这两个线程返回相同的数字，导致算法中断。虽然简单语句s_curr++ 看似不可分割，但实际却并非如此。 忘记同步 这是最简单的一种数据争用情况：同步被完全遗忘。这种争用很少有良性的情况，也就是说虽然它们是正确的，但大部分都是因为这种正确性的根基存在问题。 这种问题通常不是很明显。例如，某个对象可能是某个大型复杂对象图表的一部分，而该图表恰好可使用静态变量访问，或在创建新线程或将工作排入线程池时通过将某个对象作为闭包的一部分进行传递可变为共享图表。 当对象（图表）从私有变为共享时，一定要多加注意。这称为发布，在后面的隔离上下文中会对此加以讨论。反之称为私有化，即对象（图表）再次从共享变为私有。 对这种问题的解决方案是添加正确的同步。在计数器示例中，我可以使用简单的联锁： static class Counter { internal static volatile int s_curr = 0; internal static int GetNext() { return Interlocked.Increment(ref s_curr); 操作系统实验报告利用 银行家算法避免死锁 Document serial number【NL89WT-NY98YT-NC8CB-NNUUT-NUT108】 计算机操作系统实验报告题目利用银行家算法避免死锁 一、实验目的： 1、加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。 2、要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效的防止和避免死锁的发生。 二、实验内容： 用银行家算法实现资源分配： 设计五个进程{p0,p1,p2,p3,p4}共享三类资源{A,B,C}的系统，例如，{A,B,C}的资源数量分别为10，5，7。进程可动态地申请资源和释放资源，系统按进程的申请动态地分配资源，要求程序具有显示和打印各进程的某一个时刻的资源分配表和安全序列；显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。 三、问题分析与设计： 1、算法思路： 先对用户提出的请求进行合法性检查，即检查请求是否大于需要的，是否大于可利用的。若请求合法，则进行预分配，对分配后 的状态调用安全性算法进行检查。若安全，则分配；若不安全，则拒绝申请，恢复到原来的状态，拒绝申请。 2、银行家算法步骤： （1）如果Requesti＜or =Need,则转向步骤(2)；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。 （2）如果Request＜or=Available,则转向步骤（3）；否则，表示系统中尚无足够的资源，进程必须等待。 （3）系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值： Available=Available-Request[i]; Allocation=Allocation+Request; Need=Need-Request; (4)系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。 3、安全性算法步骤： （1）设置两个向量 ①工作向量Work。它表示系统可提供进程继续运行所需要的各类资源数目，执行安全算法开始时，Work=Allocation; ②布尔向量Finish。它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]=false，当有足够资源分配给进程时，令Finish[i]=true。 （2）从进程集合中找到一个能满足下述条件的进程： 第五章死锁 一．选择题 1.为多道程序提供的可共享资源不足时，可能出现死锁。但是，不适当的 C 也可能产生死锁。 （A）进程优先权（B）资源的线性分配 （C）进程推进顺序（D）分配队列优先权 2.采用资源剥夺法可以解除死锁，还可以采用 B 方法解除死锁。 （A）执行并行操作（B）撤销进程 （C）拒绝分配新资源（D）修改信号量 3.产生死锁的四个必要条件是：互斥、 B 循环等待和不剥夺。 （A）请求与阻塞（B）请求与保持 （C）请求与释放（D）释放与阻塞 4.在分时操作系统中，进程调度经常采用算法。 （A）先来先服务（B）最高优先权 （C）时间片轮转（D）随机 5.资源的按序分配策略可以破坏条件。 （A）互斥使用资源（B）占有且等待资源 （C）非抢夺资源（D）循环等待资源 6.在 C 情况下，系统出现死锁。 （A）计算机系统发生了重大故障 （B）有多个封锁的进程同时存在 （C）若干进程因竞争而无休止地相互等待他方释放已占有的资源 （D）资源数远远小于进程数或进程同时申请的资源数量远远超过资源总数 7。银行家算法在解决死锁问题中是用于 B 的。 （A）预防死锁（B）避免死锁 （C）检测死锁（D）解除死锁 8.支持多道程序设计的操作系统在运行过程中，不断地选择新进程运行来实现CPU的共享，但其中不是引起操作系统选择新进程的直接原因。 （A）运行进程的时间片用完 （B）运行进程出错 （C）运行进程要等待某一事件发生 （D）有新进程进入就绪队列 9. 在下列解决死锁的方法中，属于死锁预防策略的是 B 。 （A）银行家算法 （B）有序资源分配法 （C）死锁检测法 （D）资源分配图化简法 二、综合题 1.若系统运行中出现如表所示的资源分配情况，改系统是否安全？如果进程P2此时提出资源申请（1，2，2，2），系统能否将资源分配给它？为什么？ 数据库死锁问题总结 1、死锁（Deadlock） 所谓死锁：是指两个或两个以上的进程在执行过程中，因争夺资源而造 成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系 统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力 协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象 死锁。一种情形，此时执行程序中两个或多个线程发生永久堵塞（等待），每 个线程都在等待被其他线程占用并堵塞了的资源。例如，如果线程A锁住了记 录1并等待记录2，而线程B锁住了记录2并等待记录1，这样两个线程就发 生了死锁现象。计算机系统中,如果系统的资源分配策略不当，更常见的可能是 程序员写的程序有错误等，则会导致进程因竞争资源不当而产生死锁的现象。 锁有多种实现方式，比如意向锁，共享－排他锁，锁表，树形协议，时间戳协 议等等。锁还有多种粒度，比如可以在表上加锁，也可以在记录上加锁。(回滚 一个，让另一个进程顺利进行) 产生死锁的原因主要是： （1）系统资源不足。 （2）进程运行推进的顺序不合适。 （3）资源分配不当等。 如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能 性就很低，否则就会因争夺有限的资源而陷入死锁。其次，进程运行推进顺序 与速度不同，也可能产生死锁。 产生死锁的四个必要条件： （1）互斥条件：一个资源每次只能被一个进程使用。 （2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。 破解：静态分配(分配全部资源) （3）不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。 破解：可剥夺 （4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。 破解：有序分配 这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。 死锁的预防和解除： 【转】处理sql server的死锁 --第一篇 --检测死锁 --如果发生死锁了，我们怎么去检测具体发生死锁的是哪条SQL语句或存储过程？ --这时我们可以使用以下存储过程来检测，就可以查出引起死锁的进程和SQL语句。SQL Server自带的系统存储过程sp_who和sp_lock也可以用来查找阻塞和死锁, 但没有这里介绍的方法好用。 use master go create procedure sp_who_lock as begin declare @spid int,@bl int, @intTransactionCountOnEntry int, @intRowcount int, @intCountProperties int, @intCounter int create table #tmp_lock_who ( id int identity(1,1), spid smallint, bl smallint) IF @@ERROR<>0 RETURN @@ERROR insert into #tmp_lock_who(spid,bl) select 0 ,blocked from (select * from sysprocesses where blocked>0 ) a where not exists(select * from (select * from sysprocesses where blocked>0 ) b where a.blocked=spid) union select spid,blocked from sysprocesses where blocked>0 IF @@ERROR<>0 RETURN @@ERROR -- 找到临时表的记录数 select @intCountProperties = Count(*),@intCounter = 1 from #tmp_lock_who IF @@ERROR<>0 RETURN @@ERROR 1.避免死锁的方法有哪些?答案：有一种最简单的就是：全部程序禁用，然后重启自己需要 的程序。用行级锁，不去征用大表的主键，用小事务。 2.在Sybase数据库中注册用户与数据库用户有什么区别? 答案：Sybase中没有注册用户数这个说法，如果是LICENSE中的，技术上可以忽略，用户 数EE版可以设很大，几万，SMB版可以设256个。 3.在MS SQL_Server 数据库中通过什么约束保证数据库的实体完整性 答案：可以通过建立唯一的索引、PRIMARY KEY约束、UNIQUE约束或IDENTITY约束来实现 实体完整性 4.内存有哪几种存储组织结构.请分别加以说明 中的Wait() 和notify()方法使用时应注意些什么? 答案：Wait()和notify():如果条件不满足，则等待。当条件满足时，等待该条件的线程将 被唤醒。一般用在synchronized机制中例如:线程Asynchronized(obj) {while(!condition) {();}();} 当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于 是线程A就wait（）。在另一线程B中，如果B更改了某些条件，使得线程A的condition 条件满足了，就可以唤醒线程A：线程Bsynchronized(obj) {condition = true;();}需要 注意的概念是：◆调用obj的wait（）， notify（）方法前，必须获得obj锁，也就是 必须写在synchronized（obj）{……} 代码段内。◆调用（）后，线程A就释放了obj 的锁，否则线程B无法获得obj锁，也就无法在synchronized（obj）{……} 代码段内唤 醒A. ◆当（）方法返回后，线程A需要再次获得obj锁，才能继续执行。◆如果A1， A2，A3都在（），则B调用（）只能唤醒A1，A2，A3中的一个（具体哪一个由JVM决定）。 ◆（）则能全部唤醒A1，A2，A3，但是要继续执行（）的下一条语句，必须获得obj锁， 因此，A1，A2，A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj 锁之后才能继续执行。◆当B调用notifyAll的时候，B正持有obj锁，因此，A1，A2， A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1， A2，A3中的一个才有机会获得锁继续执行。 6.用户输入一个整数.系统判断,并输出是负数还是非负数,请设计测试用例. 7.操作系统中的同步和互诉解决了什么问题 答案：同步：各个进程不知对方名字，但通过某些对象（如I/O缓冲区）的共同存取来协同 完成一项任务。互斥：互斥跟临界资源有关，因为计算机的某些资源有限，所以必须通过互 斥操作防止进程之间竞争临界资源而发生死锁，互斥操作用PV原语实现。 8.UNIX 中init 1.不许用中间变量,把String ABCDE 倒转 public class StringDemo { public static void main(String[]args) { String str="ABCD"; for (int i = ()-1; i >=0; i--) { str+=(i)); } str=("ABCD".length(), ()); }} 个数求第2大的数,不许用排序算法 3.排序算法的测试用例 1, 合并有序链表 2, 删除字符串中相邻重复元素 3, 给出了二叉树结构，要求写出广度优先遍历 4, 给定整型数组，写代码找出数组中第二大元素 5, 有关菲波那契数列问题 1.怎么判断鼠标有没有选中一条线段（如很靠近，鼠标点和线段之间的距离小于5毫米） 2.求一个矩形的中心点和一个点的连线与矩形边的交点坐标（矩形左上角坐标给出，长、宽 1.有三个批处理作业，第一个作业10:00 到达，需要执行2 小时；第二个作业在10:10 到达，需要执行1 小时；第三个作业在10:25 到达，需要执行25 分钟。分别采用先来先服务，短作业优先和最高响应比优先三种调度算法，各自的平均周转时间是多少？ 解： 先来先服务： （结束时间=上一个作业的结束时间+执行时间 周转时间=结束时间-到达时间=等待时间+执行时间） 短作业优先： 1)初始只有作业1，所以先执行作业1，结束时间是12:00，此时有作业2和3； 2)作业3需要时间短，所以先执行； 最高响应比优先： 高响应比优先调度算法既考虑作业的执行时间也考虑作业的等待时间，综合了先来先服务和最短作业优先两种算法的特点。 1)10:00只有作业1到达，所以先执行作业1； 2)12:00时有作业2和3， 作业2：等待时间=12:00-10:10=110m;响应比=1+110/60=2.8； 作业3：等待时间=12:00-10:25=95m，响应比=1+95/25=4.8； 所以先执行作业3 2.在一单道批处理系统中，一组作业的提交时刻和运行时间如下表所示。试计算一下三种作业调度算法的平均周转时间T 和平均带权周转时间W。 （1）先来先服务；（2）短作业优先（3）高响应比优先 解： 先来先服务： 短作业优先： 作业顺序： 1)8:00只有作业1，所以执行作业1； 2)9:00有作业2和3，作业3短，所以先执行3； 3)9:12有作业2和4，作业4短，所以先执行4； 高响应比优先： 作业顺序： 1)8:00只有作业1，所以执行作业1； 2)9:00有作业2和3 作业2等待时间=9:00-8:30=30m，响应比=1+30/30=2； 作业3等待时间=9:00-9:00=0m，响应比=1+0/12=1； 所以执行作业2； 3)9:30有作业3和4 作业3等待时间=9:30-9:00=30m，响应比=1+30/12=3.5； 作业4等待时间=9:30-9:06=24m，响应比=1+24/6=5； 第六章死锁 1．产生死锁的根本原因是什么？死锁发生的必要条件有哪些？ 2．阐述预先静态分配法是如何进行死锁预防的。 3．阐述按序分配资源法是如何进行死锁预防的。 4．为什么说不能通过破坏“互斥条件”来预防死锁。 5．防止死锁的分配策略中,它们各自存在的缺点有哪些？ 6．在一个真实的计算机机系统中，可用的资源和进程命令对资源的要求都不会持续很久（几个月），资源会损坏或被替换，新的进程会进入和离开系统，新的资源会被购买和添加到系统中。如果用银行家算法控制死锁，下面哪些变化是安全的（不会导致可能的死锁），并且是在什么情况下发生？ a. 增加可用资源（新的资源被添加到系统） b. 减少可用资源（资源被从系统中永久性地移出） c. 增加一个进程的Max（进程需要更多的资源，超过所允许给予的资源） d. 减少一个进程的Max（进程不再需要那么多资源） e. 增加进程的数量 f. 减少进程的数量 7．考虑下面的一个系统在某一时刻的状态： Allocation Max Available A B C D A B C D A B C D P00 0 1 2 0 0 1 2 1 5 2 0 P1 1 0 0 0 1 7 5 0 P2 1 3 5 4 2 3 5 6 P30 6 3 2 0 6 5 2 P40 0 1 4 0 6 5 6 使用银行家算法回答下面问题： a. Need矩阵的内容是怎样的？ b. 系统是否处于安全状态？ c. 如果从进程P1发来一个请求（0,4,2,0），这个请求能否立刻被满足？ 8．现有三个进程P1，P2，P3，共享A，B，C这三类资源，进程对资源的需求量和目前分配情况如下： 进程已占资源数最大需求数 A B C A B C P1 2 6 3 2 6 5 P2 2 0 1 4 5 3 P3 2 1 0 2 8 5 若系统还有剩余资源数分别为A类2个，B类6个，C类2个，请按银行家算法回答下列问题： 一个经典的多线程同步问题 程序描述： 主线程启动10个子线程并将表示子线程序号的变量地址作为参数传递给子线程。子线程接收参数 -> sleep(50) -> 全局变量++ -> sleep(0) -> 输出参数和全局变量。 要求： 1．子线程输出的线程序号不能重复。 2．全局变量的输出必须递增。 下面画了个简单的示意图： 分析下这个问题的考察点，主要考察点有二个： 1．主线程创建子线程并传入一个指向变量地址的指针作参数，由于线程启动须要花费一定的时间，所以在子线程根据这个指针访问并保存数据前，主线程应等待子线程保存完毕后才能改动该参数并启动下一个线程。这涉及到主线程与子线程之间的同步。 2．子线程之间会互斥的改动和输出全局变量。要求全局变量的输出必须递增。这涉及到各子线程间的互斥。 下面列出这个程序的基本框架，可以在此代码基础上进行修改和验证。 //经典线程同步互斥问题 #include HANDLE handle[THREAD_NUM]; int i = 0; while (i < THREAD_NUM) { handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL); i++;//等子线程接收到参数时主线程可能改变了这个i的值} //保证子线程已全部运行结束 WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE); return 0; } unsigned int__stdcall Fun(void *pPM) { //由于创建线程是要一定的开销的，所以新线程并不能第一时间执行到这来int nThreadNum = *(int *)pPM; //子线程获取参数 Sleep(50);//some work should to do g_nNum++; //处理全局资源 Sleep(0);//some work should to do printf("线程编号为%d 全局资源值为%d\n", nThreadNum, g_nNum); return 0; } 运行结果： 2010年第12期吉林省教育学院学报 N o .12,2010 第26卷J O U R N A LO FE D U C A T I O N A LI N S T I T U T EO FJ I L I NP R O V I N C E V o l .26(总240期) T o t a l N o .240 收稿日期:2010—07—25作者简介:哈森格日乐,女,内蒙古兴安盟广播电视大学,讲师。研究方向:计算机应用。 操作系统中死锁与死机现象的教学比较 哈森格日乐 (内蒙古兴安盟广播电视大学,内蒙古兴安盟137400) 摘要:死锁是计算机操作系统中的一个突出问题。死锁与死机是两个不同又有关联的概念。本文从死锁与死机的概念、 产生的原因及排除三个方面进行了比较论述。 关键词:死锁;死机;进程中图分类号:G 642.0 文献标识码:A 文章编号:1671—1580(2010)12—0071—02 操作系统中的死锁可定义为:各并发进程彼此互相等待对方所拥有的资源,且这些并发进程在得到对方的资源之前不会释放自己所拥有的资源。从而造成大家都想得到资源而又都得不到资源,各并发进程不能继续向前推进的状态。它是操作系统核心在内部管理和控制的调度设计中造成系统无法继续运行的“死机”现象。 一、产生死锁与“死机”的原因(一)死锁的起因及必要条件 死锁的起因是并发进程的资源竞争。产生死锁的根本原因在于系统提供的资源个数少于并发进程所要求的该类资源数。显然,由于资源的有限性,不可能为所有要求资源的进程无限制地提供资源。但是,可以采用适当的资源分配算法,以达到消除死锁的目的。然而要达到消除死锁的目的必须了解产生死锁的必要条件。这个我们从死锁的概念就可以得到。1.互斥条件。并发进程所要求和占有的资源是不能同时被两个以上进程使用或操作的,进程对它所需要的资源进行排他性控制;2.不剥夺条件。进程所获得的资源在未使用完毕之前,不能被其他进程强行剥夺,而只能由获得该资源的进程自己释放;3.部分分配。进程每次申请它所需要的一部分资源,在等待新资源的同时,继续占用已分配到的资源;4.环路条件。存在一种进程循环链,链中每一个进程已获得的资源同时被下一个进程所请求。 (二)“死机”的原因1.W i n d o w s 的即插即用功能,简化了新硬件的安装,但随之而来的是系统启动时,总是要搜索所有的驱动程序再决定运行。因此,某些失效硬件的驱动程序会导致“死机”。 2.资源耗尽:“蓝屏”故障常常发生在进行一项比较大或比较多的工作时,或是在保存复制的时候,往往发生得比较突然。这类故障的发生原因主要是与三个堆资源(系统资源、用户资源、G D I 资源)的占用情况有关。资源耗尽会出现“系统资源严重不足”等“蓝屏”警告。平时可以观察一下系统资源的可用比例。 3.版本冲突:尤其是不同文件管理方式。W i n 98与W i n 2000等的F A T 16/32、N T F S 就是如此。 4.注册表损坏:注册表是W i n d o w s 95之后引入的一个管理新概念,采用“表格”数据结构,其中包含了系统所有的信息。在启动和运行时,机器会读取其中的内容以配置系统,同时几乎所有重要操作都会在其中留下蛛丝马迹。通过修改,轻易实现常规操作无法实现的功能,但如果其中的信息受到破坏,那么系统就不能正常工作。 5.“碎片”太多:新安装的系统,数据的存放是连续的。不断运行工作后使文件在硬盘上的存放位置凌乱异常。即便不出现错误,系统性能也要降低。需要定期对硬盘进行碎片整理。 6.驻留主存:任务栏右下侧的系统托盘内的图标控制会使操作带来很大的方便,但这样的方便不仅降低系统性能,而且会耗尽主存和其他系统资源,最后造成系统死机。 7.卸载不完整:不完全卸载,会在系统中产生大量的垃圾文件,从而导致系统的不稳定。 71 DOI :10.16083/j .cn ki .1671-1580.2010.12.059操作系统死锁练习及答案
线程死锁
《操作系统》习题集参考答案：第6章 死锁
操作系统死锁习题集
《操作系统原理》5资源管理(死锁)习题
解决多线程中11个常见问题
操作系统实验报告利用银行家算法避免死锁完整版
操作系统(死锁)试题
数据库死锁问题总结
sql server的死锁及处理方法
避免死锁的方法有哪些
操作系统之调度算法和死锁中的银行家算法习题答案
1产生死锁的根本原因是什么
4：一个经典的多线程同步问题汇总
操作系统中死锁与死机现象的比较
相关主题
文本预览