BENEMERITA UNIVERSIDAD AUTONOMA

DE PUEBLA

Facultad de Ciencias de la Computación

Carrera: Ingeniería en Ciencias de la Computación.

“Programación distribuida y aplicada”

“REPORTE DE PRÁCTICA 1”

Docente: María Luz Adolfina Sánchez Gálvez

Rivera Sánchez José Gustavo

Matrícula: 201643346
Severo José Leonardo Iván
Matrícula: 201662334
Ciclo: Otoño 2023
Fecha de entrega: 28 de agosto del 2023.
 INDICE
INTRODUCCIÓN Y OBJETIVO ............................................................................................................... 3
SUSTENTO TEÓRICO ............................................................................................................................ 4
Hilos. ................................................................................................................................................ 4
Estados de hilos. .............................................................................................................................. 4
Creación de hilos con interfaz Runnable. ........................................................................................ 5
Exclusión mutua y sincronización.................................................................................................... 5
DESARROLLO ....................................................................................................................................... 6
Código ............................................................................................................................................. 6
Clase Sistema................................................................................................................................... 7
Clase Contenedor. ........................................................................................................................... 8
Clase Brazo. ..................................................................................................................................... 9
RESULTADOS: Ejecución código................................................................................................ 10
Código Segunda parte ................................................................................................................... 11
Implementación ............................................................................................................................ 11
CONCLUSIÓN ..................................................................................................................................... 15
INTRODUCCIÓN Y OBJETIVO

Retomar conocimientos aprendidos anteriormente sobre hilos, además de

familiarizarse con los métodos de exclusión mutua y synchronized bajo el
entorno de desarrollo de java.
El objetivo consiste en implementar un sistema que permita vaciar un
contenedor. Este sistema presenta un problema de sección crítica. El sistema se
compone de dos brazos robots y un contenedor con piezas, compartido por
ambos. Cada brazo tiene como propósito tomar una determinada cantidad de
piezas del contenedor, de manera que entre los dos brazos robots logren vaciar
el contenedor. Los brazos pueden tomar la misma o diferente cantidad de piezas.
En un principio, el contenedor cuenta con 50 piezas y con las siguientes
restricciones:

• Un brazo sólo puede tomar una pieza cada vez que accede al contenedor.
• Para evitar colisiones entre los brazos, el acceso al contenedor debe ser
en exclusión mutua, es decir, los dos brazos no pueden descargar piezas
del contenedor simultáneamente.
• De igual forma para la segunda parte del programa se busca implementar
un sistema de producción compuesto por dos contenedores compartidos
y dos brazos robots capaces de tomar piezas de los contenedores de
manera coordinada para producir unidades de un producto. también es un
problema de sección crítica, donde en vez de un único recurso compartido
como en el sistema anterior, en este caso hay dos.
SUSTENTO TEÓRICO
Hilos.

Un hilo, mejor conocido en programación como thread es definido como un

proceso ligero el cual permite principalmente la ejecución de varios procesos o
diferentes trozos de código de manera simultánea. Además, al momento de
implementar un programa en el entorno de desarrollo de java se creará un hilo
principal de forma obligatoria, este es denominado hilo principal y de forma
general se encarga de ejecutar los distintos objetos del programa, según se vayan
produciendo las llamadas entre métodos. Los hilos pueden ejecutar código en
diferentes objetos, código diferente en el mismo objeto o incluso el mismo
código en el mismo objeto y al mismo tiempo. Cabe mencionar que un objeto
en java no está protegido lo que nos quiere decir que cualquier cantidad de hilos
pueden ejecutar código dentro del objeto.

Estados de hilos.

El ciclo de vida de un hilo comprende diversos estados ya que los métodos son
los encargados de transportar de un estado a otro. Un estado puede considerarse
en estado “nuevo” cuando un hilo es creado con el operador new y de igual
forma puede considerarse en estado “listo” cuando es lanzado con el método
start().
Cuando un hilo obtiene un tiempo de procesador pasa al estado de ejecución y
una vez ahí el hilo puede bloquearse por diversos motivos tales como:
• Por ejecutar el método sleep().
• Por intentar adquirir el cerrojo de un objeto.
• A través de la ejecución del método wait(). Saldrá de este estado cuando
se ejecute el método notify() o notifyAll() por parte de otro hilo.
Creación de hilos con interfaz Runnable.

La interfaz Runnable debe ser implementada por cualquier clase cuyas

instancias estén destinadas a ser ejecutadas por un hilo. La clase debe definir un
método de no argumentos llamado run.
Esta interfaz está diseñada para proporcionar un protocolo común para los
objetos que desean ejecutar código mientras están activos. Por ejemplo,
Runnable es implementado por la clase Thread. Estar activo simplemente
significa que un hilo se ha iniciado y aún no se ha detenido.

Exclusión mutua y sincronización .

Los algoritmos de exclusión mutua (comúnmente abreviada como mutex por

mutual exclusión) se usan en programación concurrente para evitar que entre
más de un proceso a la vez en la sección crítica. La sección crítica es el
fragmento de código donde puede modificarse un recurso compartido.
DESARROLLO
Código

Para implementar el sistema se deberán crear tres clases: Contenedor, Brazo y

Sistema. La clase Contenedor representa el recurso compartido por los dos
brazos y es el objeto del proceso de vaciado. El constructor de la clase debe
permitir asignar un identificador único al contenedor y configurar la cantidad
de piezas que contiene inicialmente. Además, debe ofrecer como parte de su
interfaz el método descargarUnaPieza(). Este método deberá decrementaren una
unidad la cantidad de piezas existentes en el contenedor. La clase Brazo
implementa una abstracción del brazo robot. Cada brazo es un proceso en el
sistema concurrente, por lo que, esta clase deberá implementar la interfaz
Runnable. El constructor de la clase tendrá tres parámetros de entrada: un
identificador único asignado al brazo, el número de piezas que deben ser
tomadas por el brazo durante su actividad y, finalmente, el contenedor
sobre el que debe trabajar. Esta clase únicamente deberá implementar el
método run(),responsable de tomar del contenedor compartido el número de
piezas indicado. Finalmente, la clase Sistema es la aplicación que configura
y ejecuta el sistema. Contendrá el método main() donde serán declarados los
elementos que constituyen el sistema: un contenedor de 50 piezas y dos
brazos robots que tendrán como propósito vaciarlo. Inicialmente, cada brazo
puede estar configurado para tomar 25 piezas del contenedor, aunque este
parámetro puede ser posteriormente modificado.
Clase Sistema
Clase Contenedor.
Clase Brazo.
RESULTADOS: Ejecución código
Código Segunda parte

Ahora se nos pide implementar que el programa contenga dos contenedores y un método para
ensamblar una determinada cantidad de piezas por cada brazo. Además, la clase contenedor no fue
modificada.

Implementación

El sistema también consta de tres clases Java: Contenedor, Brazo Producción y Sistema Producción.
La clase Contenedor es la misma que el problema anterior. La clase Brazo Producción es similar a la
clase Brazo implementada anteriormente. Esta nueva versión de brazo robot debe ser capaz de
trabajar con dos contenedores de manera coordinada. Por tanto, los cambios para esta nueva
versión son: el constructor de la clase Brazo Producción debe tener como parámetro de entrada dos
contenedores (además de su identificador único y el número de unidades del producto a montar);
y el métodorun() debe trabajar con ambos contenedores para el montaje de las unidades.
Finalmente, la clase Sistema Producción configura y ejecuta el sistema de producción.

Mostraremos el código de la parte del SistemaProduccion

La clase Contenedor quedara de la siguiente forma
La parte codificada de la clase BrazoProduccion se vera de la siguiente forma
Al compilar dicho programa obtendremos la siguiente salida.
CONCLUSIÓN

La elaboración de la presente práctica funciono como proceso aplicable a la

teoría vista en clase para la solución a problemas con el desarrollo de la
exclusión mutua comprendiendo en que momentos y para qué tipo de casos se
necesita evitar que 2 o más procesos ingresen al mismo tiempo a un recurso, en
este caso se logró una correcta implementación haciendo que el proceso se
optimizara y tuviera una ejecución más eficaz. A través del método synchronize
en java fue posible la intercalación de los hilos del programa. Los
conocimientos adquiridos en esta práctica servirán de base ideal para futuras
implementaciones de programas relacionados al tema.
Al realizar la segunda parte a la hora de compilar dudamos un poco si el
resultado era el adecuado para lo que se solicitaba, pero al preguntar a nuestra
profesora el resultado esperado nos dimos cuenta de que, si es el adecuado, ya
que ella menciono que al poner una cantidad de 30 el resultado no iba a marcar
la cantidad de 30, si no que iba a ser menor, pero si colocábamos un numero
menor la salida si saldría con el número exacto.
Esta práctica nos sirve de mucho para recordar algunos elementos que tal
vez hayamos olvidado, nos permite darnos cuenta como es que funciona un
programa el cual tiene algunas restricciones como lo es que no se puedan meter
ambos brazos al mismo tiempo para sacar el contenido. Esto lo podemos ver en
un ambiente de la vida real en un trabajo donde por falta de comunicación dos
trabajadores quieran realizar la misma tarea, esto lo que ocasiona es falta de
comunicación, un posible caos y en su defecto perdidas de trabajo y tiempo en
la producción de lo que se esté realizando. Por eso es importante entender los
términos de sincronización y de cómo es que se realiza una exclusión mutua
para que no sucedan desastres que nos lleven a tener problemas y en su defecto
deficiencia en el trabajo que se esté realizando.