Algoritmo bancario [Algoritmo de aprendizaje]
Prefacio
2023-8-14 18:18:01
El siguiente contenido es de "[Algoritmo de aprendizaje]"
y está destinado únicamente a fines de aprendizaje y comunicación.
derechos de autor
Elimine las siguientes palabras cuando publique en otras plataformas.
Este artículo se publicó por primera vez en la plataforma CSDN.
El autor es CSDN@日星月云.
La página de inicio del blog es https://blog.csdn.net/qq_51625007.
Elimine las siguientes palabras palabras anteriores al publicar en otras plataformas.
recomendar
Capítulo 3 Programación del procesador y punto muerto [sistema operativo]: 7. Evite el punto muerto
algoritmo bancario
7. Evite los puntos muertos
7.1 Estado de seguridad del sistema
En el método para evitar interbloqueos, el estado del sistema se divide en un estado seguro y un estado inseguro. Cuando el sistema se encuentra en un estado seguro, se pueden evitar los interbloqueos. Por el contrario, cuando el sistema se encuentra en un estado inseguro, puede entrar en un estado de punto muerto.
1 estado seguro
En este método, los procesos pueden solicitar recursos dinámicamente, pero el sistema primero debe calcular la seguridad de esta asignación de recursos antes de asignarlos. Si esta asignación no hace que el sistema entre en un estado inseguro, el recurso se puede asignar al proceso, de lo contrario, el proceso se hace esperar.
2 Transición del estado seguro al estado inseguro
Si los recursos no se asignan en una secuencia segura, el sistema puede pasar de un estado seguro a un estado inseguro.
Después de establecer el concepto de estado de seguridad del sistema, podemos saber que la idea básica para evitar un punto muerto es garantizar que el sistema esté siempre en un estado seguro. Un sistema se encuentra inicialmente en un estado seguro. Cuando un proceso solicita un recurso disponible, el sistema necesita calcular la solicitud del proceso. Si el sistema todavía está en un estado seguro después de asignar el recurso al proceso, el recurso se asignará. al proceso.
7.2 Utilice el algoritmo bancario para evitar un punto muerto
1 Estructura de datos en el algoritmo bancario
Para implementar el algoritmo bancario, se deben configurar cuatro estructuras de datos en el sistema, que se utilizan para describir los recursos disponibles en el sistema, la demanda máxima de recursos por todos los procesos, la asignación de recursos en el sistema y cuántos Todos los procesos necesitan recursos.Condición.
(1) Vector de recursos disponibles Disponible. Esta es una matriz que contiene m elementos. Cada elemento representa el número de recursos disponibles de un tipo. Su valor inicial es el número de todos los recursos disponibles de este tipo configurados en el sistema. Su valor varía con la asignación y asignación de este tipo de recursos Reciclar y cambiar dinámicamente. Si Disponible[j]=K, significa que hay K recursos Rj existentes en el sistema.
(2) Matriz de demanda máxima Máx. Esta es una matriz n × m que define la demanda máxima de m tipos de recursos para cada uno de los n procesos del sistema. Si Max[i,j]=K, significa que el número máximo de recursos de tipo Rj requeridos por el proceso i es K.
(3) Matriz de asignación Asignación. Esta también es una matriz n × m, que define la cantidad de recursos actualmente asignados a cada proceso para cada tipo de recurso en el sistema. Si Asignación [i, j] = K, significa que la cantidad de recursos de tipo Rj actualmente asignados al proceso i es K.
(4) Matriz de demanda Necesidad. Esta también es una matriz n × m que se utiliza para representar la cantidad de recursos diversos que cada proceso aún requiere. Si Need[i,j]=K, significa que el proceso i todavía necesita K recursos de tipo Rj para completar su tarea.
Existe la siguiente relación entre las tres matrices anteriores:
Necesidad[i,j]=Max[i,j]-Asignación[i,j]
2 Algoritmo bancario
Sea Requesti el vector de solicitud del proceso Pi. Si Requesti[j]=K, significa que el proceso Pi necesita K recursos de tipo Rj. Cuando Pi envía una solicitud de recurso, el sistema verifica de acuerdo con los siguientes pasos:
(1) Si Requesti[j]≤Need[i,j], vaya al paso (2), en caso contrario se considera un error porque la cantidad de recursos que requiere ha excedido el valor máximo que anunció.
(2) Si Requesti[j]≤Available[j], vaya al paso (3); de lo contrario, significa que no hay suficientes recursos y Pi debe esperar.
(3) El sistema asigna tentativamente recursos para procesar Pi y modifica los valores en la estructura de datos.
(4) El sistema ejecuta el algoritmo de seguridad para verificar si el sistema está en un estado seguro después de esta asignación de recursos. Si es seguro, los recursos se asignarán oficialmente para procesar Pi para completar esta asignación; de lo contrario, esta asignación de prueba se invalidará, se restaurará el estado de asignación de recursos original y el proceso Pi esperará.
3 algoritmo de seguridad
El algoritmo de seguridad ejecutado por el sistema se puede describir de la siguiente manera:
(1) Establecer dos vectores: ① Vector de trabajo Trabajo, que representa la cantidad de diversos recursos que el sistema puede proporcionar para que el proceso continúe ejecutándose. Contiene m elementos. Al comienzo de la ejecución del algoritmo de seguridad, Trabajo = Disponible; ② Finalizar: Indica si el sistema tiene suficientes recursos asignados al proceso para completar su operación. Al principio, establezca Finish[i]=false; cuando se asignen suficientes recursos al proceso, establezca Finish[i]=true.
(2) Encuentre un proceso de la colección de procesos que satisfaga las siguientes condiciones:
①Finalizar[i]=falso;
②Necesidad[i,j]≤Trabajo[j];
Si lo encuentra, realice el paso (3); de lo contrario, realice el paso (4).
(3) Después de que el proceso Pi obtiene recursos, se puede ejecutar sin problemas hasta que se complete y se liberen los recursos asignados, por lo que debe ejecutarse:
Trabajo[j] = Trabajo[j] + Asignación[i,j];
Finalizar[i] = verdadero;
vaya al paso 2;
(4) Si se cumple Finish[i]=true de todos los procesos, significa que el sistema está en un estado seguro; de lo contrario, el sistema está en un estado inseguro.
Implementación del algoritmo Java
código
package os.chapter3._3_6_1;
import java.util.Arrays;
public class BankerAlgorithm {
private final int[][] max; // 最大需求矩阵
private final int[][] allocation; // 已分配矩阵
private final int[][] need; // 剩余需求矩阵
private final int[] available; // 可用资源向量
private final int processNum; // 进程数量
private final int resourceNum; // 资源数量
public BankerAlgorithm(int[][] max, int[][] allocation, int[] available) {
this.max = max;
this.allocation = allocation;
this.need = new int[max.length][max[0].length];
this.available = available;
this.processNum = max.length;
this.resourceNum = max[0].length;
initNeed();
}
public void initNeed(){
for (int i = 0; i < processNum; i++) {
for (int j = 0; j < resourceNum; j++) {
this.need[i][j] = max[i][j] - allocation[i][j];
}
}
}
// 银行家算法
public void bankerAlgorithm(int[] request,int p) {
System.out.println("==========================================");
System.out.println("检查初始时的安全性");
//初始时刻的安全性
int[] safeSequence = safetyCheck();
if (safeSequence==null){
System.out.println("初始时系统不安全");
}else{
// 输出安全序列
System.out.println("Safe Sequence:");
for (int i : safeSequence) {
System.out.print("P" + i + " ");
}
System.out.println();
}
System.out.println("==========================================");
System.out.println("检查是否满足条件1");
for(int j=0;j<resourceNum;j++){
if(request[j]>need[p][j]){
System.out.println("P"+p+"所需要的资源已超过它所宣布的最大值");
return;
}
}
System.out.println("检查是否满足条件2");
for(int j=0;j<resourceNum;j++){
if(request[j]>available[j]){
System.out.println("尚无足够资源，P"+p+"必须等待");
return;
}
}
System.out.println("==========================================");
//试探分配
System.out.println("开始试探分配");
System.out.println("P"+p+":"+Arrays.toString(request));
for(int j=0;j<resourceNum;j++){
available[j]=available[j]-request[j];
allocation[p][j]=allocation[p][j]+request[j];
need[p][j]=need[p][j]-request[j];
}
System.out.println("开始安全检查");
int[] s = safetyCheck();
if (s!=null) {
System.out.println("可以分配"+"P"+p+":"+Arrays.toString(request));
} else {
System.out.println("不能分配"+"P"+p+":"+Arrays.toString(request));
}
System.out.println("==========================================");
}
// 安全性检查算法
public int[] safetyCheck() {
int[] work; // 工作向量
work = Arrays.copyOf(available, available.length);
boolean[] finish = new boolean[processNum]; // 进程是否完成执行的标志
int[] safeSequence = new int[processNum]; // 安全序列
int count = 0; // 记录已完成的进程数量
// 初始化完成标志数组
for (int i = 0; i < processNum; i++) {
finish[i] = false;
}
// 寻找可执行的进程直到全部进程执行完毕或者找不到可执行的进程
while (count < processNum) {
boolean found = false;
// 遍历所有进程，查找满足资源需求的进程
for (int i = 0; i < processNum; i++) {
if (!finish[i] && checkResources(i,work)) {
for (int j = 0; j < resourceNum; j++) {
work[j] += allocation[i][j];
}
finish[i] = true;
safeSequence[count] = i;
count++;
found = true;
}
}
// 如果没有找到满足资源需求的进程，则认为系统不安全
if (!found) {
return null;
}
}
return safeSequence;
}
// 检查进程的资源需求是否小于等于可用资源
private boolean checkResources(int process,int[] work) {
for (int i = 0; i < resourceNum; i++) {
if (need[process][i] > work[i]) {
return false;
}
}
return true;
}
public static void main(String[] args) {
int[][] max = {
{
7, 5, 3}, {
3, 2, 2}, {
9, 0, 2}, {
2, 2, 2}, {
4, 3, 3}};
int[][] allocation = {
{
0, 1, 0}, {
2, 0, 0}, {
3, 0, 2}, {
2, 1, 1}, {
0, 0, 2}};
int[] available = {
3, 3, 2};
BankerAlgorithm banker = new BankerAlgorithm(max, allocation, available);
int[] request1={
1,0,2};
banker.bankerAlgorithm(request1,1);
int[] request4={
3,3,0};
banker.bankerAlgorithm(request4,4);
int[] request0={
0,2,0};
banker.bankerAlgorithm(request0,0);
}
}
resultado
==========================================
检查初始时的安全性
Safe Sequence:
P1 P3 P4 P0 P2
==========================================
检查是否满足条件1
检查是否满足条件2
==========================================
开始试探分配
P1:[1, 0, 2]
开始安全检查
可以分配P1:[1, 0, 2]
==========================================
==========================================
检查初始时的安全性
Safe Sequence:
P1 P3 P4 P0 P2
==========================================
检查是否满足条件1
检查是否满足条件2
尚无足够资源，P4必须等待
==========================================
检查初始时的安全性
Safe Sequence:
P1 P3 P4 P0 P2
==========================================
检查是否满足条件1
检查是否满足条件2
==========================================
开始试探分配
P0:[0, 2, 0]
开始安全检查
不能分配P0:[0, 2, 0]
==========================================
Process finished with exit code 0
por fin
2023-8-14 18:20:16
Todos tenemos un futuro brillante
Les deseo todo lo mejor en sus exámenes de ingreso a posgrado, les deseo todo el éxito
en su trabajo, deseo que todos obtengan lo que desean, den me gusta, recopilen y sigan.