Solicitud: Código fuente del algoritmo bancario en Java
class ThreadTest {
static int type = 4, num = 10 //define el número de recursos y el número de subprocesos
static int[] recurso = new int[tipo] // Número total de recursos del sistema
//static int[] copyResource = new int[tipo];
static Random rand = new Random();
static Bank[] banco = new Bank[num] // /Grupo de subprocesos
Bank temp = new Bank(); ;
public void init() {
// Inicializa cada hilo del grupo y completa aleatoriamente el número total de recursos del sistema
for(int i = 0; i lt; tipo; i )
recurso [i] = rand.nextInt(10)
System.out.print("Recurso: "); p>
for(int i = 0; i lt; tipo; i )
System.out.print(" " recurso[i]);
System.out .println ("");
for(int i = 0; i lt; bank.length; i )
banco[i] = nuevo Banco("#" i) ;
}
public ThreadTest4() {
init();
}
clase Banco extiende Thread {
// Algoritmo bancario para evitar interbloqueos
public int[]
max = new int[type], //Total*.** requisitos
necesidad = new int[tipo], //recursos aún necesarios
asignación = nuevo int[tipo] //asignado
public int[] < / p>
solicitud = new int[tipo], //recurso solicitado
copyResource = new int[tipo]; //copiar recurso
private boolean isFinish = false; // ¿Se completó el hilo?
int[][] table = new int[bank.length][type*4] //Tabla de asignación de recursos bidimensional
private; void init() {
//Completa aleatoriamente el total ***, aún necesario, asignado
sincronizado(recurso) {
for(i
nt i = 0; i lt; tipo; i ) {
max[i] = rand.nextInt(5)
necesidad[i] = rand.nextInt(10; );
asignación[i] = max[i] - necesidad[i];
recurso[i] -= asignación[i] // Restar de los recursos del sistema Recursos asignados;
}
impresora();
for(int i = 0; i lt; tipo; i) {
if( recurso[i] lt; 0) {
// Si ocurre un error que indica que el recurso asignado excede el recurso total del sistema, salga
System.out.println ("La suma de ¡Las asignaciones de subprocesos están fuera de rango!");
System.exit(1);
}
}
}
}
}
p>
banco público(String s) {
setName(s) ;
init();
inicio();
}
banco público() {
// none
}
public void run() {
prueba {
sleep(rand.nextInt(2000)
p>}
catch(InterruptedException e) {
throw new RuntimeException(e);
}
while( true) {
// Continuar solicitando recursos mientras el programa no esté completo
if(askFor() == false) {
try {
dormir(1000);
}
catch(InterruptedException e) {
lanzar nueva RuntimeException(e); p> }
}
else
tryRequest();
if(noNeed() == verdadero)
break;
}
//Dormir durante un período de tiempo para simular el funcionamiento del programa
probar {
dormir(1000);
}
catch(InterruptedException e) {
lanzar nueva RuntimeException(e); p>
}
System.out.println(getName() " ¡Listo! ");
sincronizado(recurso) {
//Fin de operación para liberar recursos ocupados
for(int i = 0; i lt; type; i) {
recurso[i] = asignación[i];
<p> necesidad[i] = asignación[i] = max[i] = 0;
}
}
}
}
impresora vacía privada() {
//imprime la información del recurso actual
System.print(" " asignación[i]);
System.out.print("Requiere: ");
for(int i = 0; i lt; type; i)
System.out.print( " " necesita[i]);
System.out.print(" Disponible: ");
for(int i = 0; i lt; type; i) p>
System.out.print(" " recurso[i]);
System.out.print(" " recurso[i]);
Sistema .out .print(" " recurso[i]); solicitud[i] = necesidad[i];
}
for(int i = 0; i lt; tipo; i) //evitar solicitar aleatoriamente los 0 recursos
if(request[i] gt; 0)
canAsk = true;
sincronizado(recurso) {
// Bloquea los recursos disponibles para comprobar si se exceden
for(int i = 0; i lt; type; i) {
if(request [i] gt; recurso[i])
//Si solicita más recursos de los disponibles, espere un tiempo antes de volver a aplicar
return false;
}
}
return canAsk;
}
}
private void tryRequest() {
//crea una réplica del intento de solicitud de asignación <
sincronizado(recurso) {
for(int i = 0; i lt; type; i )
// Aún evita que las solicitudes salgan del alcance
if(request[i] gt; recurso[i])
Volver ;
for(int i = 0; i lt; type; i) {
// Copia la cantidad de recursos y resta una copia de la cantidad solicitada
copiarRecurso[i] = recurso[i];
copiarRecurso[i] -= solicitud[i];
}
Sistema
em.out.print(getName() "Solicitud: ");
for(int i = 0; i lt; type; i)
System.out.print(" " solicitud [i]);
System.out.println("");
if(checkSafe() == true) {
// Si checkSafe asigna valor de copia al recurso y modifica la ocupación y la demanda
for(int i = 0; i lt; type; i) {
recurso[i] = copyResource[i] ;
asignación[i] = solicitud[i];
necesidad[i] -= solicitud[i];
}
System.out.println (getName() "¡Solicitud exitosa!"
}
else
System.out.println(getName() "); ¡La solicitud falló ");
}
}
checkSafe booleano privado() {
// El algoritmo bancario verifica la seguridad
p>sincronizado(banco) {
// Verifique la seguridad colocando la información de recursos del subproceso en la tabla de asignación de recursos bidimensional, 0~tipo recursos disponibles /tipo~tipo*2 recursos requeridos/tipo *2~escriba*2 recursos requeridos.
tipo*2~tipo*3 recursos ocupados/tipo*3~-1 recursos ocupados disponibles
for(int i = 0; i lt; bank.length; i) {
for(int j = tipo; j lt; tipo*2; j) {
tabla[i][j] = banco[i].necesidad[jtipo];
}
for(int j = tipo*2; j lt; tipo*3; j) {
tabla[i][j] = banco[i].asignación[jtipo] ;
}
> }
// clasificación burbujeante en orden ascendente de los recursos necesarios
for(int i = 0; i lt; banco.longitud; i) {
for(int j = i; j lt; banco.longitud-1; j) {
sort(j, 4); /p>
}
}
//Realizar control de seguridad en este momento
for(int i = 0; i lt; type; i ) {
tabla[0][i] = copyResource[i];
tabla[0][i tipo*3] = tabla[ 0][i] tabla[0 ] [escribo*2];
if(tabla[0][escribo*3] lt; tabla[1][escribo])
devuelve falso;
}
for(int j = 1; j lt; bank.length-1; j ) {
for(int k = 0; k lt; tipo ; k ) {
tabla[j][k] = tabla[j-1][k tipo*3];
tabla[j][k tipo*3] = tabla [j][k] tabla [j][k tipo*2];
if(tabla[j][k tipo*3] lt; tabla[j 1][k tipo])< / p>
Devuelve falso
}
}
Devuelve verdadero
}
private void sort(int j, int k) {
//ordenación de burbujas recursiva
int tempNum;
if(table[j][k] gt ; tabla[j 1][k]) {
for(int i = tipo; i lt; tipo*2; i) {
tempNum = tabla[j][i ] ;
tabla[j][i] = tabla[j 1][i];
tabla[j 1][i] = tempNum
/* temp = banco[j];
banco[j] = banco[j 1]
banco[j 1] = temp ; */
}
>
else if(table[j][k] == table[j 1][k] amp; amp; k lt; type*) 2) //Si este recurso es el mismo ordena recursivamente el siguiente recurso y evitar fuera del rango
sort(j, k 1);
}
private boolean noNeed() {
// ¿Necesita este recurso?
boolean Finish = true;
for(int(table[j][k] == table[j 1][k] amp;p>
for(int i = 0; i lt; type; i) {
if(necesidad[i] != 0) {
terminar = false ;
romper
}
}
Volver al final
}
}
public static void main(String[] args) {
ThreadTest t = new ThreadTest()
// Subproceso de backend, establece el tiempo de ejecución antes de que el programa finalice automáticamente
new Timeout(30000, "---Stop!!!!! ---");
}
}