Juan Lorenzo Luna Canul

Matricula: 920074198

Materia: Programación Concurrente

Maestro: Juan Maya Cilia

Actividad 9. Proyecto Integrador Etapa 2

 Etapa 1

 ¿Qué es la programación concurrente?

Es la simultaneidad en la ejecución de múltiples tareas interactivas. Estas tareas

pueden ser un conjunto de procesos o hilos de ejecución creados por un único
programa. Las tareas se pueden ejecutar en una sola unidad central de
proceso (multiprogramación), en varios procesadores o en una red
de computadores distribuidos. La programación concurrente está relacionada con
la programación paralela, pero enfatiza más la interacción entre tareas. Así, la
correcta secuencia de interacciones o comunicaciones entre los procesos y el
acceso coordinado de recursos que se comparten por todos los procesos o tareas
son las claves de esta disciplina.

 ¿Qué ventajas y desventajas tiene?

Ventajas

 Permite optimizar el uso de recursos en sistemas mono/multiprocesador.

 Fiable administración de los datos en sistemas con gran información
 Mejor aprovechamiento de la CPU
 Permite el desarrollo de aplicaciones que no se vean afectadas en tiempo
real
 Permite compartir recursos entre tareas lentas y tareas rápidas para que las
tareas lentas no retrasen mucho a las rápidas.
 Velocidad de ejecución.
 Menores tiempos de respuesta.

Desventajas

 Consumos de recursos cuando hay excesos de hilos o procesos

 Dificultad de desarrollo.
 Dificultad de verificación.
 En programas con pocas instrucciones en más lento
 Si se aplica mal puede llevar a resultados erróneos.

 ¿Qué es la sección crítica?

La sección crítica es la parte que debe protegerse de interferencias de otros

procesos. También se define como a la porción de código de un programa de
computador el cual accede a un recurso compartido (estructura de datos o
dispositivo) que no debe de ser accedido por más de un hilo en ejecución (thread).
La sección crítica por lo general termina en un tiempo determinado y el hilo,
proceso o tarea solo tendrá que esperar un período determinado de tiempo para
entrar.
 ¿Qué son los problemas Race Condition e interbloqueo?

El interbloqueo se puede detectar comprobando si existe una secuencia de

terminación de procesos (similar a la sec. segura):

Sea L la lista de procesos del sistema y R el conjunto de recursos disponibles

1. Buscar en L un proceso que puede continuar con los

recursos disponibles en R
2. si no se encuentra ningún proceso, ir al paso 5
3. suponer que P termina (lo retiramos de L) y que libera los
recursos que retiene (los añadimos a R)
4. volver al paso 1
5. Si L no está vacía, hay interbloqueo

 Formas de solucionar los problemas de sección crítica

Para solucionar estos inconvenientes hay que identificar las secciones de código
en las que se pueden dar condiciones de carrera y permitir que solo un hilo entre a
estas secciones a la vez. Podríamos pensar en un cruce de autos como una
sección critica, en la que los autos que vayan en otro sentido no podrán ingresar al
cruce hasta que los carros del carril que tiene el semáforo en verde (tienen
permiso de entrar a la sección critica) terminen de pasar.

Entonces es necesario diseñar un protocolo que los procesos puedan usar, y los
requisitos que éste tiene son los siguientes:

1. Mutua exclusión: Si un proceso se ejecuta en su sección crítica entonces

ningún otro proceso puede estar en su sección crítica.

2. Progreso: Si no hay procesos en su sección crítica y hay procesos que

quieren ingresar se tiene que sólo aquellos que estén en su sección
restante puede participar de la decisión de qué proceso ingresa.

3. Espera limitada: Existe un límite para permitir que otros procesos ingresen
en sus zonas críticas.
Etapa 2

Descripción

El objetivo de la primera parte del Proyecto Integrador es instalar el IDE de

desarrollo para java (NetBeans) y realizar un primer programa (algoritmo) en el
que se aplique la programación concurrente mediante el uso de hilos.

Planteamiento

“Imagina un almacén en el que se tiene cinco despachadores que atienden tales

algunos llegan tarde. Llevado a programación tendríamos un hilo que encola los
Retardos, incrementado un contador en uno por cada Retardo y cinco hilos
ejecutándose a la vez los cuales verifican el contador, si es mayor que cero
atienden el excrementando el contador en uno”
Algoritmo

// Definimos unos sencillos hilos. Se detendrán un rato

// antes de imprimir sus nombres y retardos

class TestTh extends Thread {

private String nombre;
private int retardo;

// Constructor para almacenar nuestro nombre

// y el retardo
public TestTh( String s,int d ) {
nombre = s;
retardo = d;
}

// El metodo run() es similar al main(), pero para

// threads. Cuando run() termina el thread muere
public void run() {
// Retasamos la ejecución el tiempo especificado
try {
sleep( retardo );
} catch( InterruptedException e ) {
;
}

// Ahora imprimimos el nombre

System.out.println( "Hola Mundo! "+nombre+" "+retardo );
}
}

public class MultiHola {

public static void main( String args[] ) {
TestTh t1,t2,t3;

// Creamos los threads

t1 = new TestTh( "Thread 1",(int)(Math.random()*2000) );
t2 = new TestTh( "Thread 2",(int)(Math.random()*2000) );
t3 = new TestTh( "Thread 3",(int)(Math.random()*2000) );

// Arrancamos los threads

t1.start();
t2.start();
t3.start();
}
}
Atleta

/*
* Para cambiar este encabezado de licencia, elija los encabezados de licencia en
Propiedades del proyecto.
* Para cambiar este archivo de plantilla, seleccione Herramientas | Plantillas
* y abrir la plantilla en el editor.
*/
paquete carrera;

/ **
*
* @author PC
*/
clase pública atleta extiende Hilo {
competidor privado int
int distancia privada;

atleta pública () {
}

atleta pública (competidor int) {

this.competidor = competidor;
esto.distancia = 0;
}

public int getCompetidor () {

volver competidor
}

El conjunto de vacío público Competidor (int competidor) {

this.competidor = competidor;
}

public int getDistancia () {

vuelta distancia;
}

público vacío setDistancia (int distancia) {

esta.distancia = distancia;
}

public void run () {

System.out.println ("Competidor" + this.competidor + "iniciando la carrera");

 while (this.distancia <100) {
this.esperarXsegundos (1);
this.distancia + = (int) (Math.random () * 5) +1;
// System.out.println ("Metros recorridos por" + this.competidor + ":" +
this.distancia);
}
System.out.println ("Competidor" + this.competidor + "finalizo carrera");
}

vacío privado esperarXsegundos (int segundos) {

tratar {
Thread.sleep (segundos * 1000);
} catch (InterruptedException ex) {
Thread.currentThread (). Interrupt ();
}
}

Referencias.

 NetBeans (2016). NetBeans IDE 8.2 Installation Instructions [Sitio Web].

Recuperado de https://netbeans.org/community/releases/82/install.html

 NetBeans (2012). NetBeans IDE 8.2 Download [Sitio Web]. Recuperado de

https://netbeans.org/downloads/

 Jenkov, J. (2015). Creating and Starting Java Threads [Sitio Web]. Recuperado de
http://tutorials.jenkov.com/java-concurrency/creating-and-starting-threads.html

 “Fundamentos de Sistemas Operativos”, Silberschatz, Galvin, Gagne, Séptima

Edición, 2005. http://lsi.ugr.es/~jagomez/index_archivos/3SincronizacionComm.pdf