Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Integrantes Del Grupo 17:: Tania Pachuca Solares Ventura Meza Martínez
Integrantes Del Grupo 17:: Tania Pachuca Solares Ventura Meza Martínez
1. Con base en el material consultado en la unidad resuelve los ejercicios que se plantean
acerca de los siguientes temas:
Parte I
1. Descarga e instala el compilador de Java, a partir de la versión 7.
2. Descarga e instala algún IDE de desarrollo para Java de tu elección, para compilar y
correr programas.
3. Realiza la compilación y corrida del programa Tuberia.java.
4. Describe el código, haciendo énfasis en las partes en las que se realiza la concurrencia
y cómo se maneja.
5. Utiliza las librerías semaphore.h y pthread.h. Ubícalas en el lugar de las librerías
dentro del Sistema Operativo Linux.
6. Revisa el código programa.c. Describe el código y realiza al menos 2 corridas del
programa.
7. Elabora un breve informe de los resultados, archivos y problemáticas que se
desarrollan al correrlo.
Parte II
8. Elabora un programa en Java basándote en el programa Tuberia.java, para modelar
el “Problema del barbero dormilón”, que se describe a continuación, utilizando
HILOS, como en el programa de la tubería:
Identifica la región crítica, los hilos, la concurrencia, etc.
Considera los resultados de la solución implementada, si cumple con los
criterios expresados y cómo se evitan fallos
10. Redacta una conclusión sobre la comunicación entre procesos, utilizando semáforos,
su utilidad y los problemas que crees que se puedan resolver utilizando esta técnica.
12. Al finalizar, vuelve a la plataforma y sigue los pasos que se indican para enviar tu
actividad.
DESARROLLO PARTE 1:
1.- Instalamos Ubuntu en Windows 11.
Instalamos Java 11, a través del comando sudo apt install openjdk-11-jdk, en la
terminal de Ubuntu.
2.- Instalamos el IDE NetBeams.
3.- Realizamos la compilación del código sin que corriera exitosamente.
4.- El código lo que realiza es asigna un hilo al productor y uno al consumidor. Las
reglas para evitar problemas las configuramos de tal manera que cuando el
almacén (Buffer) esta lleno el productor deja de producir y cuando el almacén esta
vacío el consumidor deja de consumir.
5.- La librería Semaphore.h en Linux está en: Equipo/usr/src/linux-hwe-6.2.0-
26/include/linux y pthread.h en Equipo/usr/share/man/man7.
6.- Se revisa el código, donde la parte clave en los hilos, esta al monitorear el
estado del buffer, e indicando al consumidor que pare cuando el buffer este vacío
y al productor que pare cuando el buffer esta lleno.
Se modifica el código y funcionó correctamente:
CODIGO FUENTE:
CLASE BUFFER:
package com.mycompany.a3_eq17;
import java.util.logging.Level;
import java.util.logging.Logger;
siguiente--;
this.estaLlena = false;
if(siguiente == 0){
this.estaVacia = true;
}
notifyAll();
return this.buffer[this.siguiente];
}
buffer[siguiente] = c;
siguiente++;
this.estaVacia = false;
if(siguiente == this.buffer.length){
this.estaLlena = true;
}
notifyAll();
}
CLASE PRODUCTOR:
package com.mycompany.a3_eq17;
import java.util.logging.Level;
import java.util.logging.Logger;
CLASE COMSUMIDOR:
package com.mycompany.a3_eq17.
public Consumidor(Buffer b) {
this.buffer = b;
}
package com.mycompany.a3_eq17;
p.start();
c.start();
}
}
Evidencia:
7.- Debido a nuestra falta de conocimiento en ambiente Linux y programación en
java, fue bastante complejo para nosotros y entretenido a la vez, al final de
cuentas con varios tutoriales, pudimos lograrlo.
PARTE 2:
Se adjunta Código Fuente y evidencia de la programación:
CONCLUSION:
La utilización de los semáforos nos permitirá ejecutar varios hilos de manera
ordenada, para que de esta forma, se puedan ejecutar en un orden, sin un semáforo,
pueden venir problemas de concurrencia o de carrera. Estos problemas se
solucionan con los semáforos, las funciones wait() y sleep(), como lo realizamos en
la parte 1 de esta actividad.
Referencias:
II. Interbloqueos
2.1 Aplicación de los principios de interbloqueo
• Desarrolla los ejercicios en los que apliques los principios del interbloqueo. Para
ello realiza lo siguiente:
Desarrollo de la actividad:
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
#include <cstring>
using std::string;
#include <cstdlib> // system(" ") limpiar
void menu();
void Ingresar(struct Datos Persona[],int,int);
void Mostrar(struct Datos Persona[],int);
void ImprFicha(struct Datos Persona[],int,int);
void Buscar(struct Datos Persona[],int);
void BuscaFicha(struct Datos Persona[],int);
void BuscaNombre(struct Datos Persona[],int);
void BuscaTel(struct Datos Persona[],int);
void Modificar(struct Datos Persona[],int);
void Eliminar(struct Datos Persona[], int& numero, int TAM);
struct Cumpleanos
{
string Nacimiento;
};
struct Datos
{
string Nombre;
string Direccion;
string Telefono;
Cumpleanos Fecha;
};
int main()
{
const int LEN = 2;
Datos Persona[LEN];
int index = 0;
int opcion;
bool salir;
do
{
menu();
cout << "\n\t Elija la opcion: ";
cin >> opcion;
cin.ignore();
switch (opcion)
{
case 1:
system(" ");
Ingresar(Persona,index,LEN);
index++;
break;
case 2:
system(" ");
Mostrar(Persona,index);
break;
case 3:
system(" ");
Buscar(Persona,index);
break;
case 4:
system(" ");
Modificar(Persona,index);
break;
case 5:
system(" ");
Eliminar(Persona, index, LEN);
break;
case 6:
salir = true;
break;
default:
system(" ");
cout << "Ingrese Opcion valida\n\n";
break;
}
}while(salir == false);
return 0;
}
void menu()
{
cout << "\t AGENDA \n\n";
cout << "\t 1. Ingresar." << endl;
cout << "\t 2. Mostrar Registros." << endl;
cout << "\t 3. Buscar contacto." << endl;
cout << "\t 4. Modificar." << endl;
cout << "\t 5. Eliminar." << endl;
cout << "\t 6. SALIR." << endl;
}
string tel;
cout << "Digite Telefono Movil: ";
getline(cin,tel);
cout << endl;
for(int i=0 ; i<numero ; i++)
{
if(tel == Persona[i].Telefono)
{
ImprFicha(Persona,i);
cout << " Nombre: ";
getline(cin,Persona[i].Nombre);
cout << " E-mal Id [email protected]: ";
getline(cin,Persona[i].Direccion);
cout << " Telefono Movil: ";
getline(cin,Persona[i].Telefono);
cout << " Fecha de nacimiento: ";
getline(cin, Persona[i].Fecha.Nacimiento);
cout << endl << endl;
}
}
}
Resultados
Reflexionando sobre las mejores prácticas para abordar los desafíos planteados por
los interbloqueos en un sistema operativo, especialmente en relación con los
procesos dentro del mismo sistema, se pueden identificar estrategias efectivas.
La prevención del interbloqueo se enfoca en eliminar las cuatro condiciones
necesarias para su aparición. Aunque la exclusión mutua es inevitable para ciertos
recursos, se puede evitar el interbloqueo si un proceso necesita permiso de
escritura. La retención y espera se resuelve solicitando todos los recursos
simultáneamente para iniciar la ejecución. La no apropiación se supera expropiando
los recursos de un proceso que solicita un recurso no asignado. Evitar el círculo
vicioso de espera requiere una ordenación total de los recursos y la solicitud
ordenada de los mismos.
El enfoque de tratamiento del interbloqueo varía. Ignorar el problema es una práctica
riesgosa adoptada por algunos sistemas. Emplear algoritmos que aseguren la
imposibilidad del interbloqueo se presenta en dos formas: prevención y evasión. La
prevención evita las condiciones de Coffman que generan el interbloqueo. La
evasión monitorea los recursos disponibles, posesión y solicitudes para otorgar o
denegar recursos. Detectar el interbloqueo y aplicar técnicas de recuperación es
otro enfoque útil.
La comprensión de estas prácticas y su aplicación puede ayudar a evitar, resolver
o manejar eficazmente los problemas de interbloqueo, garantizando un
funcionamiento más confiable y fluido del sistema operativo y sus procesos.
Conclusiones:
Es crucial diseñar sistemas de manera que la posibilidad de interbloqueo quede
completamente excluida. Existen dos tipos de métodos para prevenir el
interbloqueo: los indirectos y los directos. Los métodos indirectos se enfocan en
evitar que cualquiera de las tres condiciones necesarias para el interbloqueo
(condiciones 1 a 3) se presente. Por otro lado, los métodos directos se centran en
evitar la formación del círculo vicioso de espera (condición 4). A continuación,
exploraremos las técnicas relacionadas con cada una de estas cuatro condiciones.
Referencias:
Castellanos, L. (2014). Sistemas Operativos [Sitio web]. Recuperado de
https://lcsistemasoperativos.files.wordpress.com/2015/02/sistemas−operativos−luis
−castellanos.pdf
Carreto, J., García, F., Miguel de, P. y Pérez, F. (2007). Sistemas operativos: Una
visión aplicada [Archivo PDF]. Recuperado de
http://laurel.datsi.fi.upm.es/_media/docencia/asignaturas/dso/interbloqu
eos−4pp.pdf
Álvarez, C. (2014). Ejemplo de Java Singleton (Patrones y ClassLoaders) [Sitio
web]. Recuperado de https://www.arquitecturajava.com/ejemplo−de−java−
singleton−patrones−classloaders/