UNIVERSIDAD NACIONAL TECNOLÓGICA DE LIMA SUR

FACULTAD DE INGENIERÍA Y GESTIÓN

Escuela Académico Profesional de Ingeniería de Sistemas

ALGORITMO DEL BANQUERO

Trabajo presentado en cumplimiento

parcial de la materia de Sistemas

de Tiempo Real

Por:

Álvarez Ttito, Andrés

Gutiérrez de la Cruz, Jonathan Steve

Guzmán Cantera, Victor Andrés

Laura López, William

Sánchez Ahuite, Fabio Cesar

Videla Mozombite, Riber

Ciudad Universitaria

2019
 DEDICATORIA

Trabajo de investigación dedicada a nuestros padres por su

apoyo incondicional.

ii
 TABLA DE CONTENIDO

DEDICATORIA ................................................................................................................................... ii
TABLA DE CONTENIDO ............................................................................................................... iii
LISTA DE FIGURAS .......................................................................................................................... iii
LISTA DE TABLAS ............................................................................................................................. v
INTRODUCCIÓN .............................................................................................................................. vi
CAPÍTULO I .......................................................................................................................................... 1
¿QUÉ ES EL ALGORITMO DEL BANQUERO?........................................................................ 1
1.1 Algoritmo del banquero .................................................................................................... 1
CAPÍTULO II ........................................................................................................................................ 3
ESTRUCTURA Y COMPLEJIDAD ................................................................................................. 3
2.1 Estructura y complejidad ...................................................................................................... 3
2.2 Pseudocódigos. ....................................................................................................................... 4
2.2.1 Pseudocódigo en C# ......................................................................................................... 4
2.2.2 Pseudocódigo en Java ....................................................................................................... 6
CAPÍTULO III ....................................................................................................................................... 8
VENTAJAS Y DESVENTAJAS DEL ALGORITMO DEL BANQUERO ............................. 8
3.1 Ventajas ................................................................................................................................... 8
3.2 Desventajas ............................................................................................................................. 8
CASO PRÁCTICO ................................................................................................................................ 9
Paso 1: .................................................................................................................................................. 9
Paso 2: ................................................................................................................................................ 10
Paso 3: ................................................................................................................................................ 11
Paso 4: ................................................................................................................................................ 11
Paso 5: ................................................................................................................................................ 11
REFERENCIA BIBLIOGRAFICA ................................................................................................. 13

LISTA DE FIGURAS
iii
Figura 1. Tabla de procesos ................................................................................................................. 4
Figura 2 . Ejemplo del Pseudocódigo en C# ................................................................................... 6
Figura 3. Pseudocódigo en Java ......................................................................................................... 7
Figura 4 . Compilado de Java.............................................................................................................. 7

iv
 LISTA DE TABLAS

Tabla 1 Matriz de recursos del sistema en estado seguro .................................................................................................................. 9

Tabla 2 Vector de recursos del sistema en estado seguro ................................................................................................................... 9
Tabla 3 Matriz de recursos del sistema Actual ................................................................................................................................ 9
Tabla 4 Vector de recursos disponibles del sistema Actual ............................................................................................................... 9
Tabla 5 Primera matriz diferencia de la matriz de recursos del estado seguro del sistema y la matriz de recursos A ....................... 10
Tabla 6Primera comparación entre el vector de recursos de con la matriz diferencia ........................................................................ 10
Tabla 7Primera comparación del vector de recursos disponibles del sistema actual con la primera matriz diferencia ......................... 10
Tabla 8Primera asignación de recursos de la matriz de recursos del sistema actual con los valores del vector de recursos disponibles del
sistema actual ................................................................................................................................................................................ 10
Tabla 9Vector de recursos del sistema actual luego de asignar los valores designados hacia la matriz de recursos del sistema actual. 10
Tabla 10Primer resultado de la matriz de recursos del sistema actual. ........................................................................................... 11
Tabla 11Segunda matriz de diferencia de recursos del sistema en estado seguro y la matriz de recursos del sistema actual ............... 11
Tabla 12 Vector de recursos del sistema actual luego de devolver los recursos usados en el proceso 2 ................................................ 11
Tabla 13 Segundo resultado de la matriz de recursos actual ........................................................................................................... 11
Tabla 14 Vector de recursos del sistema actual luego de devolver los recursos usados en el proceso 1 ................................................ 11
Tabla 15 Tercer resultado de la matriz de recursos actual .............................................................................................................. 12
Tabla 16 Vector de recursos disponibles del sistema actual luego de devolver los recursos usados en el proceso 3 .............................. 12
Tabla 17 Cuarto resultado de la matriz de recursos actual ............................................................................................................ 12
Tabla 18 Vector de recursos disponibles luego de devolver los recursos usados en el proceso 4 .......................................................... 12

v
 INTRODUCCIÓN

El presente trabajo trata de explicar y dar a conocer el “Algoritmo del banquero”, el cual
es utilizado para ceder recursos a procesos que solicitan dada una cantidad máxima de recursos
a ofrecer.

El algoritmo consiste en estudiar cada solicitud de recursos que realiza un proceso, al

ocurrir esta determina si su otorgamiento conduce a un estado seguro. En caso afirmativo se
otorga la solicitud; en caso contrario se pospone. Para ver si el estado es seguro el sistema verifica
si tiene recursos suficientes para satisfacer a otro proceso.

Algoritmo propuesto por

vi
 CAPÍTULO I

¿QUÉ ES EL ALGORITMO DEL BANQUERO?

1.1 Algoritmo del banquero

El Algoritmo del banquero, en sistemas operativos es una forma de evitar el interbloqueo,

propuesta por primera vez por Edsger Dijkstra. Es un acercamiento teórico para evitar los
interbloqueos en la planificación de recursos. Requiere conocer con anticipación los recursos
que serán utilizados por todos los procesos. Esto último generalmente no puede ser satisfecho
en la práctica.

Este algoritmo usualmente es explicado usando la analogía con el funcionamiento de un

banco. Los clientes representan a los procesos, que tienen un crédito límite, y el dinero
representa a los recursos. El banquero es el sistema operativo.

El banco confía en que no tendrá que permitir a todos sus clientes la utilización de todo
su crédito a la vez. El banco también asume que si un cliente maximiza su crédito será capaz de
terminar sus negocios y devolver el dinero a la entidad, permitiendo servir a otros clientes.

El algoritmo mantiene al sistema en un estado seguro. Un sistema se encuentra en un

estado seguro si existe un orden en que pueden concederse las peticiones de recursos a todos
los procesos, previniendo el interbloqueo. El algoritmo del banquero funciona encontrando
estados de este tipo.

Los procesos piden recursos, y son complacidos siempre y cuando el sistema se mantenga
en un estado seguro después de la concesión. De lo contrario, el proceso es suspendido hasta
que otro proceso libere recursos suficientes.

En términos más formales, un sistema se encuentra en un estado seguro si existe una

secuencia segura. Una secuencia segura es una sucesión de procesos, ,..., , donde
para un proceso , el pedido de recursos puede ser satisfecho con los recursos disponibles

sumados los recursos que están siendo utilizados por , donde j < i. Si no hay suficientes

recursos para el proceso , debe esperar hasta que algún proceso termine su ejecución y

1
libere sus recursos. Recién entonces podrá tomar los recursos necesarios, utilizarlos y
terminar su ejecución. Al suceder esto, el proceso i+1 puede tomar los recursos que necesite,
y así sucesivamente. Si una secuencia de este tipo no existe, el sistema se dice que está en
un estado inseguro, aunque esto no implica que esté bloqueado.

Así, el uso de este tipo de algoritmo permite impedir el interbloqueo, pero supone una
serie de restricciones:

 Se debe conocer la máxima demanda de recursos por anticipado.

 Los procesos deben ser independientes, es decir que puedan ser ejecutados en cualquier
orden. Por lo tanto, su ejecución no debe estar forzada por condiciones de
sincronización.
 Debe haber un número fijo de recursos a utilizar y un número fijo de procesos.
 Los procesos no pueden finalizar mientras retengan recursos.

2
 CAPÍTULO II

ESTRUCTURA Y COMPLEJIDAD

2.1 Estructura y complejidad

Se deben utilizar cuatro estructuras de datos para implementar el algoritmo del banquero.
Estas codifican el estado del sistema de asignación de recursos. Sea n, el número de procesos
del sistema, m el número de tipos de recursos. Se necesita:

Recursos (disponible): Un vector de longitud m que mantiene la cantidad total de

recursos, de cada tipo, que pueden ser utilizados por los procesos. De esta forma, Recursos[i] =
k significa que hay una cantidad total k de recursos tipo disponibles.

Demanda (Max): Esta matriz, n x m, guarda las cantidades máximas de recursos de cada
tipo que pueden ser demandadas por cada proceso. Si Max[i][j]=k, el proceso i, puede solicitar,
como máximo k instancias del recurso j.

Asignación: En esta matriz, n x m, número de recursos de cada tipo actualmente asignados

a cada proceso. Asignación[i][j] = k significa que el proceso i tiene asignado k unidades del
recurso j.

Necesidad: Una matriz, n x m, que indica la necesidad restante de recursos de cada

proceso. Si Necesidad[i][j] = k, entonces el proceso i puede necesitar k instancias del tipo de
recurso j. Observe que Necesidad[i][j] = Max[i][j] - Asignación[i][j].

En términos de complejidad, el algoritmo del banquero es de orden O(n2 × m),

donde n es el número de procesos y m la cantidad de recursos.

A continuación, se presenta un ejemplo:

Utilizando el algoritmo del banquero resuelva el siguiente problema, indicando el orden

en que los procesos pasan a ser estados seguros evitando el problema del interbloqueo.

3
 Figura 1. Tabla de procesos

A la derecha se tienen 5 procesos, cada uno tiene recursos de tipo A, B y C. En la primera

columna de asignados está la cantidad de recursos que el proceso ha obtenido a lo largo de un
tiempo; en la segunda columna de Máximo Necesario, están los recursos que tiene que obtener
de cada tipo para comenzar a ser ejecutado. Por ejemplo, el P0 no ha obtenido ningún recurso
del tipo A, sólo 1 del tipo B y ninguno del tipo C, y necesita para ejecutarse haber conseguido 7
del A, 5 del B y 3 del C.

En la última columna se tienen los recursos disponibles que da el sistema, los que se
pueden utilizar con todos los procesos. Hay 3 del A, 3 del B y 2 del C.
El algoritmo del banquero trata de asegurar qué proceso tiene un “estado seguro” es decir, se
requiere alcanzar el máximo requerido entre los que estén en Asignados y los que se encuentren
en Disponibles.

2.2 Pseudocódigos.

2.2.1 Pseudocódigo en C#

int nRecursos;
int nProcesos;
List<List<int>> asignados = new List<List<int>>();
List<List<int>> maximos = new List<List<int>>();
List<int> disponibles = new List<int>();

Random r = new Random();

//Generamos las matrices aleatoriamente

for (int j1 = 0; j1 < nRecursos;j1++)
{
disponibles.Add(r.Next(0, nRecursos));
}
for (int i = 0; i < nProcesos; i++)
{

4
 asignados.Add(new List<int>());
maximos.Add(new List<int>());
for (int j = 0; j < nRecursos; j++)
{
asignados[i].Add(r.Next(0, nRecursos));
maximos[i].Add(r.Next(0, nRecursos));
}
}

bool aux = true;

for (int proc = 0; proc < nProcesos; proc++)
{
aux = true;
for (int recur = 0; recur < nRecursos; recur++)
{
// comprobamos que haya recursos suficientes

aux = (maximos[proc][recur] - asignados[proc][recur] -

disponibles[recur]) <= 0;
if (!aux)
{
break;
}
}
if (aux)
{
añadirYeliminar(ref disponibles, ref asignados, proc);
maximos.RemoveAt(proc);
nProcesos--;
proc = -1;
if (nProcesos == 0)
{
Console.WriteLine("Es estado seguro");
Console.ReadLine();
return;
}
}
}
Console.WriteLine("Es interbloqueo");
Console.ReadLine();

private static void añadirYeliminar(ref List<int> disponibles, ref

List<List<int>> asignados, int proc)
{
for (int k = 0; k < asignados[proc].Count; k++)
{
disponibles[k] += asignados[proc][k];
}
asignados.RemoveAt(proc);

5
 }

Figura 2 . Ejemplo del Pseudocódigo en C#

2.2.2 Pseudocódigo en Java

<pre>
public class Comprobaciones {

public static List<Proceso> devuelveLista(List<Proceso>

asignados, List<Proceso> necesarios, Disponibles recursos){
List<Proceso> terminados = new ArrayList<Proceso>();
for(int i = 0; i < necesarios.size(); i++){
if(!(terminados.contains(asignados.get(i))) &&
ejecuta(asignados.get(i), necesarios.get(i), recursos)){
terminados.add(asignados.get(i));
System.out.println("Proceso " +
asignados.get(i).getNombre() + " terminado");
for(int j = 0; j <
recursos.getDisponibles().size(); j++){

recursos.setDisponible(recursos.getDisponibles().get(j) +
asignados.get(i).getRecursosNecesarios().get(j), j);
}
System.out.println("Recursos disponibles:
" + recursos.getDisponibles());
i = -1;
}

}
if(terminados.size() == asignados.size()){
System.out.println("Todos los procesos han sido
ejecutados sin problemas.");
}
else{
System.out.println("Hay un interbloqueo, no se
pueden seguir ejecutando procesos...");
}
return terminados;
}

public static Boolean ejecuta(Proceso asignados, Proceso

necesarios, Disponibles disponibles){
// Devuelve True si tiene recursos suficientes...
Boolean ej = true;
for(int i = 0; i <
necesarios.getRecursosNecesarios().size(); i++){

6
 if((asignados.getRecursosNecesarios().get(i) +
disponibles.getDisponibles().get(i)) <
necesarios.getRecursosNecesarios().get(i)){
ej = false;
break;
}
}
return ej;
}

}
</pre>
<pre>
public static void main(String[] args) {

List<Proceso> asignados = creaAsignados();

List<Proceso> necesarios = creaNecesarios();
Disponibles disponibles = creaDisponibles();
Comprobaciones.devuelveLista(asignados, necesarios,
disponibles);
}
</pre>

Figura 3. Pseudocódigo en Java

Resultado:

Proceso P4 terminado
Recursos disponibles: [1, 1, 3, 2, 1]
Proceso P3 terminado
Recursos disponibles: [2, 2, 3, 3, 1]
Proceso P1 terminado
Recursos disponibles: [3, 2, 5, 4, 2]
Proceso P2 terminado
Recursos disponibles: [5, 2, 6, 5, 2]
Todos los procesos han sido ejecutados sin problemas.

Figura 4 . Compilado de Java

7
 CAPÍTULO III

VENTAJAS Y DESVENTAJAS DEL ALGORITMO DEL BANQUERO

3.1 Ventajas

 No es necesario expulsar y hacer retroceder procesos como en la detección del

interbloqueo.
 Es menos restrictivo que la prevención.

3.2 Desventajas

 Se debe conocer la máxima demanda de recursos por anticipado.

 La ejecución de los recursos no debe estar forzada por la sincronización.
 Se tiene un número fijo de procesos y recursos.
 Los procesos no finalizan mientras retengan recursos.
 Requiere que los procesos salden sus préstamos en un tiempo finito.

8
 CASO PRÁCTICO

Se tiene un sistema operativo con los siguientes procesos con sus respectivos requisitos y los
recursos disponibles que se pueden otorgar a cada proceso:

Tabla 1 Matriz de recursos del sistema en estado seguro

C R1 R2 R3
P1 3 2 2
P2 6 1 3
P3 3 1 4
P4 4 2 2

Tabla 2 Vector de recursos del sistema en estado seguro

R1 R2 R3
9 3 6

Hallar un estado seguro para A.

Tabla 3 Matriz de recursos del sistema Actual

A R1 R2 R3
P1 1 0 0
P2 6 1 2
P3 2 1 1
P4 0 0 2

Tabla 4 Vector de recursos disponibles del sistema Actual

R1 R2 R3
0 1 1

Resolución:

Paso 1: Se resta la matriz C y A

9
Tabla 5 Primera matriz diferencia de la matriz de recursos del estado seguro del sistema y la matriz de
recursos A

C-A R1 R2 R3
P1 2 2 2
P2 0 0 1
P3 1 0 3
P4 4 2 0

Paso 2: Se verifica cual fila de la matriz cumple la condición que sus elementos sean menores a los del
vector. En este caso cumple P2; luego se le agrega los valores a la matriz A Para que termine su proceso.

Tabla 6 Primera comparación entre el vector de recursos de con la matriz diferencia

C-A R1 R2 R3
P1 2 2 2
P2 0 0 1
P3 1 0 3
P4 4 2 0

Tabla 7 Primera comparación del vector de recursos disponibles del sistema actual con la primera matriz
diferencia

R1 R2 R3
0 1 1

Tabla 8 Primera asignación de recursos de la matriz de recursos del sistema actual con los valores del
vector de recursos disponibles del sistema actual

A R1 R2 R3
P1 1 0 0
P2 6+0 1+0 2+1
P3 2 1 1
P4 0 0 2

Tabla 9 Vector de recursos del sistema actual luego de asignar los valores designados hacia la matriz de
recursos del sistema actual

R1 R2 R3
0 1 1-1

10
Tabla 10 Primer resultado de la matriz de recursos del sistema actual.

A R1 R2 R3
P1 1 0 0
P2 6 1 3
P3 2 1 1
P4 0 0 2

Paso 3: Comparamos los valores actuales de C y A para verificar si se cumplió el proceso.

Tabla 11 Segunda matriz de diferencia de recursos del sistema en estado seguro y la matriz de recursos del
sistema actual

C-A R1 R2 R3
P1 2 2 2
P2 0 0 0
P3 1 0 3
P4 4 2 0

Comprobamos que el P2 es el primero en terminar ya que cumplió con todos los requisitos.

Paso 4: Los valores del proceso 2 ya terminados son devueltos al vector.

Tabla 12 Vector de recursos del sistema actual luego de devolver los recursos usados en el proceso 2

R1 R2 R3
0+6 1+1 0+3

Paso 5: Repetimos el proceso hasta que todos estén cumpliendo sus requisitos.

Tabla 13 Segundo resultado de la matriz de recursos actual

A R1 R2 R3
P1 3 2 2
P2 6 1 3
P3 2 1 1
P4 0 0 2

Tabla 14 Vector de recursos del sistema actual luego de devolver los recursos usados en el proceso 1

R1 R2 R3
7 2 3

11
Tabla 15 Tercer resultado de la matriz de recursos actual

A R1 R2 R3
P1 3 2 2
P2 6 1 3
P3 3 1 4
P4 0 0 2

Tabla 16 Vector de recursos disponibles del sistema actual luego de devolver los recursos usados en el
proceso 3

R1 R2 R3
9 3 4

Tabla 17 Cuarto resultado de la matriz de recursos actual

A R1 R2 R3
P1 3 2 2
P2 6 1 3
P3 3 1 4
P4 4 2 2

Tabla 18 Vector de recursos disponibles luego de devolver los recursos usados en el proceso 4

R1 R2 R3
9 3 6

Para lograr el estado seguro se debe realizar los procesos en el siguiente orden P2-P1-P3-P4.

12
 REFERENCIA BIBLIOGRAFICA

Barragan, A. J. (11 de Octubre de 2012). Blogspot. Obtenido de Blogspot: https://sistemas-

operativos.blogspot.com/2012/10/algoritmo-del-
banquero.html?fbclid=IwAR0xQi0CKhj6KIKxfn3sCCMWaE8G_tqq3BRPujDQGg-
lg8W3mktgYSiLu-U

Huerta, K. W. (20 de Marzo de 2012). Slideshare. Obtenido de Slideshare:

https://es.slideshare.net/zan45kbh/algoritmo-del-
baquero?fbclid=IwAR2AX9IZf3LCIYj_nh6ZjRGVgdgb5FdKOV0XO3HxucTZp0t6
Kxb82t5DrbU

Madrigal, I. (26 de Octubre de 2010). Blogspot. Obtenido de Blogspot:

http://equipoisaiasmauricio.blogspot.com/2010/10/principios-de-interbloqueo-y-
acciones.html

Sevilla, D. d. (s.f.). Wiki-SSOO. Obtenido de Wiki-SSOO: https://1984.lsi.us.es/wiki-

ssoo/index.php/Algoritmo_para_averiguar_interbloqueo?fbclid=IwAR0As68Y9sCD
_s7MKREM4HaMRra22FP_gWXXON7BXQstTZf6FlZSZYiorLM

13