银行家算法安全性序列分析
避免死锁之银行家算法
避免死锁之银行家算法分类：Operating System2013-12-28 01:14 922人阅读评论(0) 收藏举报目录(?)[+]上篇博客中进程管理之死锁我们讲到了进程管理中死锁的各种问题，其中留下了死锁避免算法中著名的银行家算法没讲，下面就为大家详细解读。
1.安全序列讲银行家算法之前，我们首先引入安全序列的定义：所谓系统是安全的，是指系统中的所有进程能够按照某一种次序分配资源，并且依次地运行完毕，这种进程序列{P1，P2，...，Pn}就是安全序列。
如果存在这样一个安全序列，则系统是安全的；如果系统不存在这样一个安全序列，则系统是不安全的。
安全序列{P1，P2，...，Pn}是这样组成的：若对于每一个进程Pi，它需要的附加资源可以被系统中当前可用资源加上所有进程Pj当前占有资源之和所满足，则{P1，P2，...，Pn}为一个安全序列，这时系统处于安全状态，不会进入死锁状态。
虽然存在安全序列时一定不会有死锁发生，但是系统进入不安全状态（四个死锁的必要条件同时发生）也未必会产生死锁。
当然，产生死锁后，系统一定处于不安全状态。
2.银行家算法(为了熟悉英语请原谅我借用wiki上的文字来描述)For the Banker's algorithm to work, it needs to know three things:∙How much of each resource each process could possibly request[CLAIMS]∙How much of each resource each process is currently holding[ALLOCATED]∙How much of each resource the system currently has available[AVAILABLE]Resources may be allocated to a process only if it satisfies the following conditions:∙request ≤ max, else set error condition as process has crossed maximum claim made by it.∙request ≤ available, else process waits until resources are available.Basic data structures to be maintained to implement the Banker's Algorithm:∙Available: A vector of length m indicates the number of available resources of each type. If Available[j] = k, there are kinstances of resource type Rj available.∙Max: An n×m matrix defines the maximum demand of each process. If Max[i,j] = k, then Pi may request at most k instances of resource type Rj.∙Allocation: An n×m matrix defines the number of resources of each type currently allocated to each process. If Allocation[i,j] = k, then process Pi is currently allocated k instance of resourcetype Rj.∙Need: An n×m matrix indicates the remaining resource need of each process. If Need[i,j] = k, then Pi may need k moreinstances of resource type Rj to complete task.Note: Need[i,j] = Max[i,j] - Allocation[i,j].∙银行家算法:设进程i提出请求Request[j]，则银行家算法按如下规则进行判断。
银行家算法-求所有安全序列
银⾏家算法-求所有安全序列银⾏家算法-求所有安全序列使⽤DFS（深度优先搜索）遍历求出所有的安全序列。
数据结构先上头⽂件说明，实现此算法⽤到的数据结构和命名。
#ifndef _DATA_STRUCTURE#define _DATA_STRUCTURE// 表⽰资源个数#define M (4)// 表⽰进程个数#define N (4)// 当前状态还剩多少可⽤的资源struct AvailableD;// 每个进程对每个资源的最⼤需求量struct MaxD;// 当前分配个每个进程的资源数⽬struct AllocationD;// 每个进程还需要多少资源数⽬（最⼤需求 - 当前分配）struct NeedD;// 当前状态每个进程请求的资源数量struct RequestD;// 存放安全序列的数据结构（名字叫 Queue 实际上是栈的实现【FILO先进后出】）struct QueueD;// 表明每个进程是否在安全序列中struct StatusD;typedef struct AvailableD *Available;typedef struct MaxD *Max;typedef struct AllocationD *Allocation;typedef struct NeedD *Need;typedef struct RequestD *Request;typedef struct QueueD *Queue;typedef struct StatusD *Status;Available create_available();Allocation create_allocation();Max create_max();Need create_need();Queue create_queue();int queue_full(Queue queue);int queue_empty(Queue queue);void queue_add(Queue queue, int data);int queue_get(Queue queue);void queue_display(Queue queue);Status create_status();void display_need(Need need);/* 更新 need 数组 */void update_need(Need need, Allocation allocation, Max max);/* 将 allocation 矩阵的第 row ⾏的值加(减)到 available ⾥ */void update_available(Allocation allocation, int row, Available available, int is_add);/* 检查 available 是否满⾜ need 的第 row ⾏的需求 */void check_available(Allocation allocation, Need need, Available available, int row, Queue queue, Status status);#endif算法步骤⾸先检查当前剩余的资源数⽬是否满⾜某个进程的需求量，也就是说判断 Available 向量中每⼀个资源数⽬是否⼤于等于 Need 矩阵中某⼀个进程的需求量；如果对于进程 row ，对每个资源数⽬的需求量⼩于当前可⽤的系统资源；⾸先检查当前进程是否已经在安全序列中，若存在就判断下⼀个进程；若当前进程 row 还没有处在安全序列，就开始深度优先搜索：将当前进程 row 已经分配到的系统资源数⽬加到当前可⽤的资源数⽬中，即 Allocation 矩阵中第row ⾏的所有数⽬加到 Available 向量中；然后将当前进程 row 添加到安全序列中（此安全序列是⼀个栈）；递归调⽤搜索的函数，向下⼀个进程开始搜索；在搜索的过程中需要判断所有的进程是否已经添加到安全序列中，即查看安全序列（栈）的⼤⼩是否等于当前系统的进程数⽬；若达到了就将安全序列输出并且开始回溯；此判断应该放在深度优先搜索函数的前⾯，⽤来作为递归出⼝；然后将最近加⼊到安全序列中的进程从安全队列中删除，即从栈中弹出⼀个元素，记为 row；然后修改此进程row未加在安全序列中的状态；将此进程row收回的资源数⽬归还，即从 Available 向量中减去 Allocation 矩阵中第 row ⾏的数⽬；然后向下⼀个进程搜索。
【计算机专业】操作系统+银行家算法详解
银行家算法开放分类：算法银行家算法是一种最有代表性的避免死锁的算法。
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。
安全状态一定是没有死锁发生。
不安全状态:不存在一个安全序列。
不安全状态一定导致死锁。
那么什么是安全序列呢？安全序列：一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
银行家算法：我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。
当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。
算法：n：系统中进程的总数m：资源类总数Available:ARRAY[1..m] of integer;Max:ARRAY[1..n,1..m] of integer;Allocation:ARRAY[1..n,1..m] of integer;Need:ARRAY[1..n,1..m] of integer;Request:ARRAY[1..n,1..m] of integer;简记符号：AvailableMaxAllocationNeedRequest当进程pi提出资源申请时，系统执行下列步骤：（1）若Request≤Need,转（2）；否则错误返回（2）若Request≤Available,转（3）；否则进程等待(3）假设系统分配了资源，则有：Available:=Available-Request; Allocation:=Allocation+Request;Need:=Need-Request若系统新状态是安全的，则分配完成若系统新状态是不安全的，则恢复原状态，进程等待为进行安全性检查，定义数据结构：Work:ARRAY[1..m] of integer;Finish:ARRAY[1..n] of Boolean;安全性检查的步骤：(1) Work:=Available;Finish:=false;(2) 寻找满足条件的i：a.Finish=false;b.Need≤Work;如果不存在，则转(4)(3) Work:=Work+Allocation;Finish:=true;转(2)(4) 若对所有i,Finish=true,则系统处于安全状态，否则处于不安全状态/* 银行家算法，操作系统概念(OS concepts Six Edition) 作者：ctu_85*/#include "malloc.h"#include "stdio.h"#define alloclen sizeof(struct allocation)#define maxlen sizeof(struct max)#define avalen sizeof(struct available)#define needlen sizeof(struct need)#define finilen sizeof(struct finish)#define pathlen sizeof(struct path)struct allocation{int value;struct allocation *next;};struct max{int value;struct max *next;};struct available{int value;struct available *next;};struct need{int value;struct need *next;};struct path{int value;struct path *next;};struct finish{int stat;struct finish *next;};int main(){int row,colum,status=0,i,j,t,temp,processtest;struct allocation *allochead,*alloc1,*alloc2,*alloctemp;struct max *maxhead,*maxium1,*maxium2,*maxtemp;struct available *avahead,*available1,*available2,*availabletemp,*workhead,*work1,*work2,*worktemp,*workte mp1;struct need *needhead,*need1,*need2,*needtemp;struct finish *finihead,*finish1,*finish2,*finishtemp;struct path *pathhead,*path1,*path2,*pathtemp;char c;printf("\nPlease enter the type of sources the system has:\n");scanf("%d",&colum);printf("Please enter the number of processes now in the memory:\n"); scanf("%d",&row);printf("Please enter the allocation array:\n");for(i=0;i<row;i++){printf("The allocation for process p%d:\n",i);for (j=0;j<colum;j++){printf("The type %c system resource allocated:\n",'A'+j);if(status==0){allochead=alloc1=alloc2=(struct allocation*)malloc(alloclen);alloc1->next=alloc2->next=NULL;scanf("%d",&allochead->value);status++;}else{alloc2=(struct allocation *)malloc(alloclen);scanf("%d,%d",&alloc2->value);if(status==1){allochead->next=alloc2;status++;}alloc1->next=alloc2;alloc1=alloc2;}}}alloc2->next=NULL;status=0;printf("Please enter the max array:\n");for(i=0;i<row;i++){printf("The max needed from process p%d:\n",i);for (j=0;j<colum;j++){printf("The type %c maxium system resource may needed:\n",'A'+j); if(status==0){maxhead=maxium1=maxium2=(struct max*)malloc(maxlen); maxium1->next=maxium2->next=NULL;scanf("%d",&maxium1->value);status++;}else{maxium2=(struct max *)malloc(maxlen);scanf("%d,%d",&maxium2->value);if(status==1){maxhead->next=maxium2;status++;}maxium1->next=maxium2;maxium1=maxium2;}}}maxium2->next=NULL;status=0;printf("Please enter the available array now exists in the system:\n"); for (j=0;j<colum;j++){printf("The type %c available system resource number:\n",'A'+j);if(status==0){avahead=available1=available2=(struct available*)malloc(avalen); workhead=work1=work2=(struct available*)malloc(avalen); available1->next=available2->next=NULL;work1->next=work2->next=NULL;scanf("%d",&available1->value);work1->value=available1->value;status++;}else{available2=(struct available*)malloc(avalen);work2=(struct available*)malloc(avalen);scanf("%d,%d",&available2->value);work2->value=available2->value;if(status==1){avahead->next=available2;workhead->next=work2;status++;}available1->next=available2;available1=available2;work1->next=work2;work1=work2;}}available2->next=NULL;work2->next=NULL;status=0;alloctemp=allochead;maxtemp=maxhead;for(i=0;i<row;i++)for (j=0;j<colum;j++){if(status==0){needhead=need1=need2=(struct need*)malloc(needlen); need1->next=need2->next=NULL;need1->value=maxtemp->value-alloctemp->value; status++;}else{need2=(struct need *)malloc(needlen);need2->value=(maxtemp->value)-(alloctemp->value); if(status==1){needhead->next=need2;status++;}need1->next=need2;need1=need2;}maxtemp=maxtemp->next;alloctemp=alloctemp->next;}need2->next=NULL;status=0;for(i=0;i<row;i++){if(status==0){finihead=finish1=finish2=(struct finish*)malloc(finilen);finish1->next=finish2->next=NULL;finish1->stat=0;status++;}else{finish2=(struct finish*)malloc(finilen);finish2->stat=0;if(status==1){finihead->next=finish2;status++;}finish1->next=finish2;finish1=finish2;}}finish2->next=NULL; /*Initialization compleated*/status=0;processtest=0;for(temp=0;temp<row;temp++){alloctemp=allochead;needtemp=needhead;finishtemp=finihead;worktemp=workhead;for(i=0;i<row;i++){worktemp1=worktemp;if(finishtemp->stat==0){for(j=0;j<colum;j++,needtemp=needtemp->next,worktemp=worktemp->next) if(needtemp->value<=worktemp->value)processtest++;if(processtest==colum){for(j=0;j<colum;j++){worktemp1->value+=alloctemp->value;worktemp1=worktemp1->next;alloctemp=alloctemp->next;}if(status==0){pathhead=path1=path2=(struct path*)malloc(pathlen); path1->next=path2->next=NULL;path1->value=i;status++;}else{path2=(struct path*)malloc(pathlen);path2->value=i;if(status==1){pathhead->next=path2;status++;}path1->next=path2;path1=path2;}finishtemp->stat=1;}else{for(t=0;t<colum;t++)alloctemp=alloctemp->next;finishtemp->stat=0;}}elsefor(t=0;t<colum;t++){needtemp=needtemp->next;alloctemp=alloctemp->next;}processtest=0;worktemp=workhead;finishtemp=finishtemp->next;}}path2->next=NULL;finishtemp=finihead;for(temp=0;temp<row;temp++){if(finishtemp->value==0){printf("\nWARNING,the system is in nonsafe status!\n");exit(0);}finishtemp=finishtemp->next;}printf("\nThe system is in safe status!\n"); printf("\nThe safe sequence is: \n");do{printf("p%d ",pathhead->value);}while(pathhead=pathhead->next);}。
银行家算法总结
银行家算法总结一、银行家算法银行家算法（Banker’s Algorithm），又称银行家管理算法，是一种专门用于系统资源管理的算法，用于解决操作系统中多个用户对多类资源的竞争请求，从而保证合理地分配公共资源，解决资源分配问题，其目的是为了保证单个进程的安全运行，同时保证系统的安全运行。
二、银行家算法的定义银行家算法是一种用于解决多个用户对多类资源的竞争请求的算法，也称作资源分配算法或资源管理算法，它可以确定是否有足够的资源可供一个或多个进程安全运行，如果有足够的资源可供运行，则可以分配该资源，否则系统将进入不满足安全状态。
三、银行家算法的特点（1）安全性：银行家算法可以确定是否有足够的资源可以满足所有进程的最大要求，使系统处于安全态；（2）在安全态下，银行家算法能够有效地检查一个进程是否可以获得资源，并且可以确定该状态下的最优解；（3）银行家算法可以有效检查一个系统是否处于安全态，它可以检查任意多个资源种类的一组资源分配是否安全；（4）银行家算法可以防止死锁的发生，可以有效地确保非抢占式多处理机系统的安全运行；（5）银行家算法设计简单，容易实现，并十分快速；（6）银行家算法不是最优的，它只是一种有效的搜索算法，其实现效率较低；四、银行家算法的使用1、资源分配问题银行家算法可以用于操作系统中的多个用户对多类资源的竞争请求，以此保证资源的合理分配，从而解决资源分配问题。
它可以有效地检查一个进程是否可以获得资源，同时可以确定该状态下的最优解。
2、进程安全性银行家算法可以用于检查一个系统是否处于安全态，并检查任意多个资源种类的一组资源分配是否安全，可以保证系统的安全运行，从而保证单个进程的安全性。
3、防止死锁银行家算法可以防止死锁的发生，这是由于它可以确定是否有足够的资源可以满足所有进程的最大要求，使系统处于安全态，从而阻止死锁发生。
银行家算法结果分析与实验心得
银行家算法结果分析与实验心得银行家算法是一种用于避免死锁的资源分配算法，用于分配有限的可用资源给多个进程或线程以避免死锁并保证安全性。
它是由银行家提出的一种资源分配算法，主要用于操作系统中的进程管理。
下面是我对银行家算法的结果分析与实验心得：1. 结果分析银行家算法的运行结果主要包括两个方面：是否发生死锁和是否保证资源安全性。
首先，通过实验可以发现，银行家算法能够有效地避免死锁的发生。
当系统中某个进程或线程请求资源时，如果系统可用的资源数量无法满足其需求，银行家算法会判断该请求是否会导致死锁的发生，如果是则拒绝该请求，直到系统可用的资源满足该请求为止。
其次，银行家算法能够保证资源的安全性。
在银行家算法中，每一个进程或线程有一个最大资源需求量和已分配资源量，系统有一个可用资源量和已分配资源量，银行家算法通过计算当前可用资源量是否能够满足某个进程或线程的资源需求来判断是否能够分配资源给该进程或线程。
在分配之前，会先对资源的状态进行检查，如果分配该资源将使系统处于不安全状态，则不能分配。
2. 实验心得在实验中，我使用了一些简单的示例来演示银行家算法的应用，例如汽车工厂生产线、餐厅就餐服务等。
在实验过程中，我发现银行家算法的确可以有效避免死锁的发生，而且能够保证资源的安全性。
但是，在实际应用中，由于每个进程或线程的资源需求量和已分配资源量的变化是动态的，因此需要不断地进行资源状态检查和更新，这会增加一定的系统开销，降低系统的性能。
另外，银行家算法也有一些局限性，如它只适用于静态资源分配问题，即资源需求量和可用资源量都是固定的，而且每个进程或线程的最大需求量必须在分配资源前就知道。
如果资源需求量和可用资源量是动态变化的，银行家算法就无法满足需求，因此需要采用其他的算法来解决这类问题。
总之，银行家算法是一种很有用的资源分配算法，它可以有效避免死锁的发生，保证资源的安全性，但在实际应用中需要根据具体情况来选择合适的算法。
银行家算法计算安全序列
银行家算法计算安全序列
银行家算法是一种用于判断系统资源分配是否安全的算法，用于避免死锁的发生。
安全序列是指系统能够按照一定的顺序满足所有进程的资源需求，同时避免死锁的发生。
下面是银行家算法计算安全序列的基本步骤：
1. 初始化：设置一个长度为n的数组work，代表可用资源的
数量，初始值为系统中每个资源的可用数量。
设置一个长度为
n的数组finish，用于记录每个进程是否已经得到了全部所需
资源，初始值均为false。
2. 循环检测：循环遍历进程，检查当前进程是否满足以下条件： - finish[i]为false（即当前进程未得到所需资源）
- 当前进程所需的资源量小于等于work（即系统有足够的资
源供当前进程使用）
如果满足以上条件，则将当前进程加入安全序列，并更新work的值，即work = work + allocation[i]。
将finish[i]设为true，表示当前进程已经得到了所需资源。
继续循环直到所有进程都满足以上条件或者没有进程满足以
上条件为止。
3. 检查安全性：检查是否存在一个安全序列，即所有进程都已经得到了所需的资源。
如果存在安全序列，则系统是安全的；否则，系统是不安全的。
通过以上步骤，可以计算出一个安全序列，用于判断系统资源分配是否安全。
操作系统课程设计报告 银行家算法
操作系统课程设计报告题目：银行家算法操作系统课程设计报告题目：银行家算法摘要在多道操作系统中，可以利用多个进程并发执行来改善系统资源利用率，提高系统的吞吐量，但也可能发生人们不想看到的危险——死锁。
为了解决这个问题，人们引入了多种机制处理死锁问题。
本文主要介绍了操作系统如何运用银行家算法和安全性算法避免死锁的产生。
同时运用Java编程语言模拟计算机内部资源分配的过程。
让读者对银行家算法有更深刻的认识。
关键字：死锁银行家算法安全性算法资源分配IAbstractIn much road OS, improve the systematic handling capacity, but also may people happened not thinking of dangerous dead lock seeing that to come to improve system resource utilization ratio being able to make use of many course concurrency to carry out. Have led into various mechanism for problem , people resolving this handle lock fast problem. The main body of a book has been introduced mainly how to apply the banker algorithm and the security algorithm to avoid lock fast creation. Wield Java programming language analog computer inside resource assignment process at the same time. Let reader have deeper cognition to banker algorithm.Key words: Algorithmic algorithmic security of dead lock banker resource assignmentII目录中文摘要 (I)英文摘要 (II)1绪论 (1)2需求分析 (2)3概要设计 (3)4详细设计 (4)5测试与分析 (6)6总结 (11)7参考文献 (12)附录 (13)1绪论银行家算法诞生的背景：操作系统作为裸机上安装的第一层软件，起着控制和管理计算机内部软硬件资源，合理组织计算机工作流程，提高计算机工作效率，用户和计算机硬件接口的重要作用。
银行家算法实验报告
银行家算法实验报告引言：在计算机科学领域，由于资源的有限性，进程资源分配问题一直备受关注。
而银行家算法被广泛应用于操作系统中，用于确保资源的安全分配。
本文旨在介绍银行家算法的原理和应用，并通过实验报告来验证该算法的有效性和可行性。
1. 银行家算法简介银行家算法是由美国学者Dijkstra提出的一种资源分配和避免死锁的算法。
其基本思想是通过银行家的原则来避免系统陷入死锁状态，保证资源分配的安全性和可行性。
银行家算法适用于具有多个进程和多个资源的并发系统中。
2. 银行家算法原理银行家算法基于两个重要的概念：安全性和可分配性。
安全性表示在系统当前状态下，是否存在一种资源分配序列可以使系统避免死锁状态。
可分配性表示系统是否能够满足进程对资源的请求。
银行家算法的实现需要以下几个关键步骤：(1) 初始化：对每个进程设置最大需求量、已分配资源量和需求资源量。
(2) 效验：判断系统当前状态下资源是否满足所有进程的需求，即判断系统是否处于安全状态。
(3) 分配：若系统处于安全状态，则根据某种资源分配策略，为进程分配资源。
(4) 请求：进程请求资源。
(5) 回收：进程释放资源。
3. 银行家算法的实验验证为了验证银行家算法的有效性和可行性，我们设置了一个简单的实验环境，模拟一个有限的资源系统，包含3个进程和3种不同类型的资源。
实验过程如下：(1) 初始化：对每个进程设置最大需求量、已分配资源量和需求资源量。
设置3个进程的最大需求量分别为{5, 4, 3}，已分配资源量分别为{1, 2, 2}，需求资源量分别为{3, 2, 0}。
(2) 效验：判断系统当前状态下资源是否满足所有进程的需求。
经过实验验证，我们发现系统当前状态下资源无法满足进程2的资源需求。
为了保证系统的安全性和避免死锁，根据银行家算法原理，我们将不满足资源需求的进程2暂停，并回滚到初始状态。
重新调整资源分配后，系统进入了安全状态。
(3) 分配：为进程1和进程3分配资源。
实验二银行家算法实验报告
实验二银行家算法实验报告一、实验目的通过本次实验，主要学习了解了银行家算法的原理和实现方式，掌握银行家算法的应用场景，了解了安全序列的概念和判断方法，并通过代码实现加深对银行家算法的理解和掌握。
二、实验过程1、阅读银行家算法的相关理论知识。
2、编写银行家算法的代码实现。
3、根据实验要求，设置不同的初始资源分配和不同的进程请求资源情况，分别计算是否存在安全序列。
三、实验结果与分析1、首先按照实验要求设置一个初始的资源分配情况：可用的资源数目：4 4 4进程数目：4各进程对三种资源的最初需要数目：Max：7 5 33 2 29 0 22 2 2已分配资源数目：Allocation：0 1 02 0 03 0 22 1 1剩余资源数目：Need： 7 4 31 2 26 0 00 1 1根据上述数据，计算出该初试分配情况下的安全序列为：1 -> 3 -> 4 -> 2。
2、然后设置一个进程请求资源的情况：进程 1 请求资源 [3,3,0]，进程 2 请求资源 [1,0,1]，进程 3 请求资源 [2,2,0]，进程 4 请求资源 [0,0,2]。
根据银行家算法，先进行安全性检测，发现该系统不存在安全序列，因此不满足银行家算法的要求，请求不被满足。
3、接着修改初始的资源分配情况和请求的资源情况，进行比较：通过以上的实验操作，得出结论：只有当请求的资源不会导致系统不再安全时，才会满足请求。
银行家算法基于这个假设进行运算，它管理着一个可以分配的表格，该表格显示系统的各种资源已经分配和未分配的情况，并确定哪些进程可以分配资源，哪些不可以。
四、实验总结本次实验通过对银行家算法的概念、原理和应用场景的了解，对该算法有了更深的认识和理解，并通过代码实现和实验操作，进一步巩固和掌握了该算法的应用方法。
在实验过程中，也有一些需要注意的问题：如需要按照一定的顺序输入原数据，正确地计算资源分配和剩余情况；核实每个请求的资源数目是否足够，才进行安全性检测；注意计算过程中数值的准确性和解题思路的正确性等。
银行家算法实验报告
2011-2012学年第一学期计算机操作系统实验报告专业：计算机科学与技术班级：学号：姓名：提交日期：实验三银行家算法模拟【开发语言及实现平台或实验环境】C++/C#Microsoft Visual Studio 6.0/ Microsoft V isual Studio .NET 2003【实验目的】（1）进一步理解利用银行家算法避免死锁的问题；（2）在了解和掌握银行家算法的基础上，编制银行家算法通用程序，将调试结果显示在计算机屏幕上，再检测和笔算的一致性。
（3）理解和掌握安全序列、安全性算法【实验要求】（1）了解和理解死锁；（2）理解利用银行家算法避免死锁的原理；（3）会使用某种编程语言。
【实验原理】一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列)，为每个进程分配所需的资源，直至最大需求，使得每个进程都能顺利完成。
二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后，表示为Requesti[j]=k。
系统按下述步骤进行安全检查：（1）如果Request i≤Need i则继续以下检查，否则显示需求申请超出最大需求值的错误。
（2）如果Request i≤A vailable则继续以下检查，否则显示系统无足够资源，Pi阻塞等待。
（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：A vailable［j］∶=A vailable［j］-Request i[j］;Allocation［i,j］∶=Allocation［i,j］+Request i［j］;Need［i,j］∶=Need［i,j］-Requesti［j］;（4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
深入解析银行家算法
深入解析银行家算法银行家算法是一种用于多进程系统的资源分配和调度算法，目的是确保系统中的各个进程能够安全地访问所需的资源，且不会发生死锁（Deadlock）的情况。
本文将深入解析银行家算法的工作原理和应用。
1. 背景和定义:银行家算法最初由Dijkstra提出，用于解决多进程系统中资源分配的问题。
它基于银行家和客户的关系类比，将系统中的资源视为银行家的资金，将进程视为客户。
银行家必须合理分配资金，以避免资金不足导致系统中的进程无法完成任务。
2. 原理:银行家算法运用了安全性检查（safety check）和资源分配策略。
安全性检查是通过模拟资源分配的情况，判断系统是否处于安全状态，即不存在死锁，可以继续分配资源。
资源分配策略是根据安全性检查的结果，将资源分配给请求资源的进程，确保系统安全性。
3. 数据结构:银行家算法使用以下数据结构：进程的最大需求矩阵(Maximum)，系统已分配资源矩阵(Allocation)，系统可用资源向量(Available)，进程的尚需资源矩阵(Need)。
这些数据结构可以反映每个进程对每种资源的需求量、已分配量和尚需量。
4. 算法流程:银行家算法的流程如下：- 系统初始化：将每个进程的最大需求矩阵、已分配资源矩阵和系统可用资源向量初始化。
- 请求资源：当某个进程请求资源时，首先检查该请求是否超出了其最大需求量和系统可用资源量，如果超出则拒绝请求；否则进入下一步。
- 模拟分配：假设分配资源给该进程，更新进程的已分配资源矩阵和系统可用资源向量。
- 安全性检查：检查系统是否处于安全状态，即不存在死锁。
该检查基于银行家算法的安全性条件，即每个进程的尚需资源量可以得到满足。
- 分配或回滚：如果安全性检查通过，则进程得到资源分配，否则回滚分配过程，恢复之前的状态。
5. 应用场景:银行家算法广泛应用于操作系统中，尤其是在多任务和多进程环境下。
它可以帮助确定是否可以分配资源给某个进程，以避免资源竞争和死锁的问题。
总结银行家算法思想
总结银行家算法思想
银行家算法是一种用于避免死锁的资源分配算法。
它的思想是通过预先计算进程所需资源的最大值，然后检查系统是否处于一个安全状态，以决定是否允许进程继续申请资源。
银行家算法的核心是对系统状态进行安全性检查。
系统状态被定义为系统中各进程当前拥有的资源数量，以及系统还剩下的资源数量。
在进行安全性检查时，银行家算法首先假设所有进程在未来的执行中，继续按最大需求申请资源，然后计算出一个安全序列。
安全序列是指一系列进程按顺序执行，每个进程都能够完成，并返回它所拥有的资源，然后释放资源给下一个进程。
如果存在至少一个安全序列，那么系统被认为是安全的。
否则，如果不存在安全序列，那么系统处于不安全状态，可能会发生死锁。
银行家算法的主要思想是，进程在申请资源之前，必须先计算出它的最大资源需求，并与系统剩余资源进行比较。
如果申请的资源不大于系统剩余资源，那么将分配给进程所需资源，并模拟系统状态的改变。
然后进行安全性检查，看是否存在安全序列。
如果存在安全序列，那么说明该进程可以继续执行。
否则，如果不存在安全序列，说明资源不足，该进程需要等待。
银行家算法的目的是避免死锁的发生，通过安全性检查来决定是否分配资源，从而保证系统的安全性和有效性。
它可以预防死锁的发生，并提供一种策略来保护系统的资源，避免进程长时间等待资源而导致的低效率。
总之，银行家算法是一种用于避免死锁的资源分配算法。
它的核心思想是在进程申请资源之前，预先计算最大资源需求，并通过安全性检查来决定是否分配资源。
它的目标是保证系统的安全性和有效性，避免死锁的发生，提高系统的性能和可靠性。
操作系统课程设计报告—银行家算法
操作系统课程设计报告题目：银行家算法院（系）：专业：班级：学生：学号：指导教师：操作系统课程设计报告摘要Dijkstra提出的银行家算法，是最具代表性的避免死锁的算法。
本文对如何用银行家算法来处理操作系统给进程分配资源做了详细的说明，包括需求分析、概要设计、详细设计、测试与分析、总结、源程序清单。
首先做了需求分析，解释了什么是银行家算法，并指出它在资源分配中的重要作用。
然后给出了银行家算法的概要设计，包括算法思路、步骤，以及要用到的主要数据结构、函数模块及其之间的调用关系等。
在概要设计的基础上，又给出了详细的算法设计，实现概要设计中定义的所有函数,对每个函数写出核心算法，并画出了流程图。
接着对编码进行了测试与分析（并在最后附上Java编写的程序代码）。
最后对整个设计过程进行了总结。
关键词：安全状态；安全序列；银行家算法；安全性算法；安全序列；流程图。
目录摘要 (1)1绪论 (4)1.1前言 (5)1.2研究意义 (5)1.3结构安排 (5)2需求分析 (4)2.1题目描述 (5)2.2银行家算法 (5)2.3基本要求 (5)2.4目的 (5)3概要设计 (4)3.1基本思路 (5)3.2银行家算法步骤 (5)3.3安全型算法步骤 (5)3.4数据结构 (5)3.4.1主要用到的数据结构 (6)3.4.2程序模块 (6)3.4.3各模块间的调用关系 (6)4详细设计 (4)4.1主要函数的核心代码 (5)4.1程序流程图 (5)5测试 (4)5.1测试用例 (5)5.1测试结果分析和截图 (5)6总结 (4)参考文献 (4)附录：原程序清单 (4)1绪论1．1前言：Dijkstra (1965)提出了一种能够避免死锁的调度算法，称为银行家算法。
它的模型基于一个小城镇的银行家，他向一群客户分别承诺了一定的贷款额度，每个客户都有一个贷款额度，银行家知道不可能所有客户同时都需要最大贷款额，所以他只保留一定单位的资金来为客户服务，而不是满足所有客户贷款需求的最大单位。
银行家算法安全性序列分析
银行家算法安全性序列分析作者：张志东来源：《科技传播》2011年第09期摘要在操作系统的处理机调度的过程中，由于竞争资源或者进程间推进顺序非法，都会导致死锁的发生。
本文主要研究如何利用银行家算法可以避免死锁，并分析银行家算法安全性序列。
关键词银行家算法；安全性序列；避免死锁中图分类号TP39 文献标识码A 文章编号 1674-6708（2011）42-0225-020引言处理死锁的方法主要包括预防死锁、避免死锁、检测死锁和解除死锁。
而利用银行家算法可以避免死锁，在这一避免死锁的过程中，银行家算法安全性序列分析是尤为重要的。
1 银行家算法中的数据结构1）空闲资源向量Available。
这是一个数组，它里面包括m个元素，这些元素都可以分别用来表示一种空闲的资源的数量的多少，系统中存储的这种全部空闲的资源的数量的多少为它的初始值，随该类资源的分配和回收，其数值发生动态地改变。
如果Available［j］=K，那么，系统中当前存在K个Rj类资源；2）最大需求矩阵Max。
Max矩阵是n×m维的，该矩阵定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max［i,j］=K，那么，进程i需要Rj类资源的最大数量的多少为K；3）分配矩阵Allocation。
Allocation矩阵是n×m维的，该矩阵定义了系统中每一类资源当前已分配给每一进程的资源数。
如果Allocation［i,j］=K，那么，进程i当前已分得Rj类资源的数量的多少为K；4）需求矩阵Need。
Need矩阵是n×m维的，该矩阵定义了所有进程仍然需求的各类资源数。
如果Need［i,j］=K，那么，为了能够完成其任务，进程i还需要Rj类资源K个。
Need［i,j］=Max［i,j］-Allocation［i,j］。
2 银行家算法设Requesti是进程Pi的请求向量，如果Requesti［j］=K，表示进程Pi需要K个Rj类型的资源。
银行家算法（安全序列）
银⾏家算法（安全序列）银⾏家算法银⾏家算法（Banker's Algorithm）是⼀个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的⼀种避免死锁产⽣的算法。
它以银⾏借贷系统的分配策略为基础，判断并保证系统的安全运⾏。
安全状态如果存在⼀个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。
安全状态⼀定是没有死锁发⽣。
不安全状态不存在⼀个安全序列。
不安全状态不⼀定导致死锁。
数据结构1）可利⽤资源向量Available是个含有m个元素的数组，其中的每⼀个元素代表⼀类可利⽤的资源数⽬。
如果Available[j]=K，则表⽰系统中现有Rj类资源K个。
2）最⼤需求矩阵Max这是⼀个n×m的矩阵，它定义了系统中n个进程中的每⼀个进程对m类资源的最⼤需求。
如果Max[i,j]=K，则表⽰进程i需要Rj类资源的最⼤数⽬为K。
3）分配矩阵Allocation这也是⼀个n×m的矩阵，它定义了系统中每⼀类资源当前已分配给每⼀进程的资源数。
如果Allocation[i,j]=K，则表⽰进程i当前已分得Rj类资源的数⽬为K。
4）需求矩阵Need。
这也是⼀个n×m的矩阵，⽤以表⽰每⼀个进程尚需的各类资源数。
如果Need[i,j]=K，则表⽰进程i还需要Rj类资源K个，⽅能完成其任务。
Need[i,j]=Max[i,j]-Allocation[i,j]算法原理我们可以把操作系统看作是银⾏家，操作系统管理的资源相当于银⾏家管理的资⾦，进程向操作系统请求分配资源相当于⽤户向银⾏家贷款。
为保证资⾦的安全，银⾏家规定：(1) 当⼀个顾客对资⾦的最⼤需求量不超过银⾏家现有的资⾦时就可接纳该顾客；(2) 顾客可以分期贷款，但贷款的总数不能超过最⼤需求量；(3) 当银⾏家现有的资⾦不能满⾜顾客尚需的贷款数额时，对顾客的贷款可推迟⽀付，但总能使顾客在有限的时间⾥得到贷款；(4) 当顾客得到所需的全部资⾦后，⼀定能在有限的时间⾥归还所有的资⾦.操作系统按照银⾏家制定的规则为进程分配资源，当进程⾸次申请资源时，要测试该进程对资源的最⼤需求量，如果系统现存的资源可以满⾜它的最⼤需求量则按当前的申请量分配资源，否则就推迟分配。
基于银行家算法的进程安全序列仿真研究
基于银行家算法的进程安全序列仿真研究摘要：银行家算法是一种应用于操作系统安全的死锁避免方法。
本文分析了银行家算法思想，给出了算法描述。
在delphi集成开发环境下进行了仿真实验，得到了进程执行的安全序列。
同时文中也对银行家算法提出了改进的意见。
关键词：进程；死锁；银行家算法；安全检查simulation research on process safe sequence based on banker’s algorithm zhang ju(department of information engineering, liaoning provincial college of communications, shenyang 110122,china)【abstract】 banker ’s algorithm is a method for the security of operating system. this paper analyzes the banker’s algorithm, gives adescription of the algorithm. the simulation experiments are carried out in the integrated development environment of delphi, which obtained the safe sequences of process. at the same time, this paper also puts forward improved opinions on the banker’s algorithm.【key words】process; deadlock; banker’s algorithm; safe sequence0 引言在计算机系统中有很多独享资源，在任何时刻它们只能被一个进程使用，比如打印机、磁带机和文件等。
银行家算法安全性序列分析
银行家算法安全性序列分析摘要：在操作系统的处理机调度的过程中，由于竞争资源或者进程间推进顺序非法，都会导致死锁的发生。
本文主要研究如何利用银行家算法可以避免死锁，并分析银行家算法安全性序列。
关键词：银行家算法；安全性序列；避免死锁引言处理死锁的方法主要包括预防死锁、避免死锁、检测死锁和解除死锁。
而利用银行家算法可以避免死锁，在这一避免死锁的过程中，银行家算法安全性序列分析是尤为重要的。
1.银行家算法中的数据结构(1)空闲资源向量Available。
这是一个数组，它里面包括m个元素，这些元素都可以分别用来表示一种空闲的资源的数量的多少，系统中存储的这种全部空闲的资源的数量的多少为它的初始值，随该类资源的分配和回收，其数值发生动态地改变。
如果Available [j] =K，那么，系统中当前存在K个Rj类资源。
(2)最大需求矩阵Max。
Max矩阵是nx m维的，该矩阵定义了系统中n 个进程中的每一个进程对m类资源的最大需求。
如果Max [i,j] =K，那么，进程i需要Rj 类资源的最大数量的多少为K。
(3)分配矩阵Allocation。
Allocation矩阵是nx m维的，该矩阵定义了系统中每一类资源当前已分配给每一进程的资源数。
如果Allocation [i,j] =K，那么，进程i当前已分得Rj类资源的数量的多少为K o(4)需求矩阵Need。
Need矩阵是nx m维的，该矩阵定义了所有进程仍然需求的各类资源数。
如果Need] i,j] =K，那么，为了能够完成其任务，进程i还需要Rj 类资源K个。
Need[i,j] =Max [ i,j] -Allocation [i,j]2.银行家算法设Requesti是进程Pi的请求向量，如果Request]j] =K，表示进程Pi需要K个Rj类型的资源。
当Pi发出资源请求后，系统按下述步骤进行检查：(1)如果Requesti [jNeed [i,j ]，便转向步骤2；否则认为出错，因为它所需要的资源数大于它仍然需要的最大值。
银行家算法实验报告
xx大学操作系统实验报告姓名：学号：班级：实验日期：实验名称：预防进程死锁的银行家算法实验三预防进程死锁的银行家算法1．实验目的：通过编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用适当的算法，有效地防止和避免死锁地发生。
理解银行家算法的运行原理，进一步掌握预防进程死锁的策略及对系统性能的评价方法。
：2. 需求分析(1) 输入的形式和输入值的范围；输入：首先输入系统可供资源种类的数量n 范围：0<n<=100资源1的名称：资源的数量：资源2的名称：资源的数量：。
输入作业的数量m 范围：0<m<=100输入个进程的最大需求量<m*n矩阵>[Max]:输入个进程已经申请的资源量<m*n矩阵>[Allocation]:(2) 输出的形式系统目前可用的资源[Avaliable]:（显示系统是否安全）分配序列：（3）程序所能达到的功能通过手动输入资源种类数量和各进程的最大需求量、已经申请的资源量，运用银行家算法检测系统是否安全，若安全则给出安全序列，并且当用户继续输入某进程的资源请求时，能够继续判断系统的安全性。
(4) 测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果。
正确输入输入参数（已申请资源数）错误3、概要设计所有抽象数据类型的定义：int Max[100][100]; //各进程所需各类资源的最大需求int Avaliable[100]; //系统可用资源char name[100] };//资源的名称int Allocation[100][100]; //系统已分配资源int Need[100][100] }; //还需要资源int Request[100]; //请求资源向量int temp[100]; //存放安全序列int Work[100];//存放系统可提供资源int M=100; //作业的最大数为100int N=100; //资源的最大数为100主程序的流程:* 变量初始化；* 接收用户输入n，m，Max ij，Allocation ij；* 按照银行家算法判断当前状态安全与否，安全给出安全序列，不安全给出提示；* 如果安全，提示用户输入下一时刻进程P k的资源请求Request(R1, … ,R m)；* 如果不安全或者无新请求则退出。
银行家算法安全序列(共4张PPT)
06526 N0(1,2,2,2)=(2,5,7,6);
➢ Need2() := Need2(2,3,5,6) - Request2(1,2,2,2) = (1,1,3,4)
3
22、解（2）- 2
Allocation
Need
Available
P0
0,0,3,2
▪ ②、Request (1,2,2,2) ≤ Available(1,6,2,2) 22、解（2）- 12
2 PAv1ailable:=1A0v0a0ilable (1,6,21,725)0- Request2(1,2,2,2)=(0,4,0,0);
PAll2ocation 123()5:4= Allocation223(15,63,5,4) + Request2(1,2,2,2)=(2,5,7,6);
▪ ③、预分配资源，有： 2P23、解（2）03-32
0652
22、解在（银1行）家此算时法的中安，全若性出：现下述资源分配情况：
PAv2ailable:=1A3v5a4ilable (1,6,22,23)5-6Request2(1,2,2,2)=(0,4,0,0);
A22llo、c解ati（on12）()此:=时A的llo安ca全tio性n ：2(1,3,5,4) + Request2(1,2,2,2)=(2,5,7,6);
0652
2 2②2、、R解e（qu2e）st-2(21,2,2,2) ≤ Available(1,6,2,2)
22、在解银（行2）家- 算1法中，若出现下述资源分配情况：
Allocation () := Allocation (1,3,5,4) + ➢ P 34
0303124
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
银行家算法安全性序列分析
摘要：在操作系统的处理机调度的过程中，由于竞争资源或者进程间推进顺序非法，都会导致死锁的发生。
本文主要研究如何利用银行家算法可以避免死锁，并分析银行家算法安全性序列。
关键词：银行家算法；安全性序列；避免死锁
引言
处理死锁的方法主要包括预防死锁、避免死锁、检测死锁和解除死锁。
而利用银行家算法可以避免死锁，在这一避免死锁的过程中，银行家算法安全性序列分析是尤为重要的。
1. 银行家算法中的数据结构
（1）空闲资源向量Available。
这是一个数组，它里面包括m个元素，这些元素都可以分别用来表示一种空闲的资源的数量的多少，系统中存储的这种全部空闲的资源的数量的多少为它的初始值，随该类资源的分配和回收，其数值发生动态地改变。
如果Available［j］=K，那么，系统中当前存在K个Rj类资源。
（2）最大需求矩阵Max。
Max矩阵是n×m维的，该矩阵定义了系统中n 个进程中的每一个进程对m类资源的最大需求。
如果Max［i,j］=K，那么，进程i需要Rj类资源的最大数量的多少为K。
（3）分配矩阵Allocation。
Allocation矩阵是n×m维的，该矩阵定义了系统中每一类资源当前已分配给每一进程的资源数。
如果Allocation［i,j］=K，那么，进程i当前已分得Rj类资源的数量的多少为K。
（4）需求矩阵Need。
Need矩阵是n×m维的，该矩阵定义了所有进程仍然需求的各类资源数。
如果Need［i,j］=K，那么，为了能够完成其任务，进程i还需要Rj类资源K个。
Need［i,j］=Max［i,j］-Allocation［i,j］
2. 银行家算法
设Requesti是进程Pi的请求向量，如果Requesti［j］=K，表示进程Pi需要
K个Rj类型的资源。
当Pi发出资源请求后，系统按下述步骤进行检查：（1）如果Requesti［j］≤Need［i,j］，便转向步骤2；否则认为出错，因为它所需要的资源数大于它仍然需要的最大值。
（2）如果Requesti［j］≤Available［j］，便转向步骤（3）；否则，表示尚无足够资源，Pi须等待。
（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：
Available［j］∶=Available［j］-Requesti［j］;
Allocation［i,j］∶=Allocation［i,j］+Requesti［j］;
Need［i,j］∶=Need［i,j］-Requesti［j］;
（4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
如果安全，就正式将资源分配给进程Pi，从而实现本次分配；反之，取消这次的试探分配，保持上一次的资源分配状态，让进程Pi等待。
3. 安全性算法
（1）设置两个向量：①工作向量Work：它表示系统可提供给进程继续运行所需的各类资源数量的多少，它含有m个元素，在执行安全算法开始时，Work∶=Available；②Finish：它表示系统是否有足够的资源分配给进程，使之运行完成。
开始时先做Finish［i］∶=false；当有足够资源分配给进程时，再令Finish［i］∶=true。
（2）从进程集合中找到一个能满足下述条件的进程：
①Finish［i］=false；
②Need［i,j］≤Work［j］；
如果找到，那么，执行步骤（3），否则，执行步骤（4）。
（3）当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它
的资源，故应执行：
Work［j］∶=Work［i］+Allocation［i,j］;
Finish［i］∶=true;
go to step 2;
（4）如果所有进程的Finish［i］=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。
4. 银行家算法安全性序列分析之例
假定系统中有五个进程｛P0, P1, P2, P3, P4｝和三类资源｛A, B, C｝，各种资源的数量分别为10、5、7，在T0时刻的资源分配情况如表1 所示。
表1 T0时刻的资源分配表
（1）T0时刻的安全性：
表2 T0时刻的安全序列
（2）P1请求资源：P1发出请求向量Request1（1，0，2），系统按银行家算法进行检查：
①Request1（1, 0, 2）≤Need1（1, 2, 2）
②Request1（1, 0, 2）≤Available1（3, 3, 2）
③系统先假定可为P1分配资源，并修改Available, Allocation1和Need1向量，由此形成的资源变化情况如表2所示。
表2 系统先假定可为P1分配资源时刻的资源分配表
④再利用安全性算法检查此时系统是否安全。
表3 P1申请资源时的安全性检查
（3）P4请求资源：P4发出请求向量Request4（3，3，0），系统按银行家
算法进行检查：
①Request4（3, 3, 0）≤Need4（4, 3, 1）;
②Request4（3, 3, 0）<Available（2, 3, 0），让P4等待。
参考文献：
[1] 崔建平. 深入探讨银行家算法[J]. 科技信息(学术研究), 2008,(17) .
[2] 侯刚. 深入解析银行家算法[J]. 潍坊学院学报, 2006,(02) .
[3] 曹现玲. 浅谈银行家算法[J]. 中国科技信息, 2008,(16) .
[4] 仲兆满,管燕. 银行家算法的改进及其在操作系统上的推广[J]. 连云港师范高等专科学校学报, 2002,(02) .
[5] 王继奎,王会勇. 基于银行家算法的进程安全序列全搜索算法[J]. 甘肃科学学报, 2009,(02) .。