Unidad 4 de Topicos avanzados de programación

1. Instituto Tecnológico Superior de Felipe Carrillo Puerto
Ingeniería en Sistemas Computacionales
Materia: Tópicos Avanzados de Programación
Docente: Dr. Niels Henryk Aranda Cuevas
Reporte Técnico
Unidad 4: Programación concurrente (multihilos)
Integrantes:
Chable Pat Jhonny Gabriel
Balam Yam Wilberth
Ayala Mutul Ezer Abizai
Vega Segura Adrián Asís
Poot Tuz Efraín Antonio
Aké Pech Jorge Manuel
Semestre: 4th
Aula: J-3 Grupo: “a”
Ciclo Escolar: Enero – Julio

2. Unidad 4: Programación concurrente (multihilos)
Fundamentos De Programación Concurrente
• Un programa multihilo contiene dos o más partes que pueden ejecutarse de forma
concurrente. Cada parte de ese programa se llama hilo (thread) y cada hilo
establece un camino de ejecución independiente. Es un tipo de multitarea distinta a
la multitarea por procesos, la cual ejecuta varios programas a la vez. En Java, es
un solo programa con varios hilos a la vez. A continuación se iniciará el desarrollo
de un ejemplo sencillo de hilos en java.
1. Ingresa a NetBeans y crea un proyecto tipo Java Application de la categoría
Java. Nombre este proyecto como dskHilos.
2. Pulse sobre el nombre del proyecto dskHilos y en el menú de contexto que
se muestra seleccione Java Package… de la opción Nuevo. Nombre esta
carpeta Logica.
3. Repita el paso anterior y cree otro paquete denominado Fisica
4. Una vez creados los paquetes pulse con el botón derecho del mouse sobre
el paquete Fisica y cree un objeto JFrame de nombre FormaHilos.
5. En JFrame creado insertar 4 tablas JTable, una en la parte superior donde
se almacenan los resultados, y tres del mismo tamaño en la parte inferior.
Cada tabla simulara valores expresados como movimientos de cada jugador.
Ubica una serie de etiquetas y botones. Las tres etiquetas que aparecen
debajo de los JTable se denominan lblJugador1, lblJugador2 y lblJugador3,
respectivamente. Más debajo de éstas aparecen 3 botones de nombre:
btnJugar, btnReinicioJuego y btnGenerarTabla.
6. Ahora proceda a crear las clases en el paquete Logica que permitirán el
funcionamiento de los tres jugadores. Procede a crear la primera clase
nómbrala clsJugador1. El código es el siguiente:

3. Código: clsJugador1.
package Logica;
import javax.swing.JOptionPane;
public class clsJugador1 extends Thread{
private int numero;
private String nombre;
private boolean continuar = true;
//Constructor
public clsJugador1()
{
numero = 1; //le asigna el numero 1 al jugador 1.
nombre = JOptionPane.showInputDialog(null,"Digite el nombre del
Jugador 1: ");
}
public int getNumero(){return numero;} //para devolver el número del
jugador
public String getNombre(){return nombre;}
public Fisica.FormaHilos formHilo; //declara una variable de tipo
FormaHilos
public clsJugador1(Fisica.FormaHilos aThis) { //constructor que
recibe
formHilo = aThis; //defecto el formulario FormaHilos y lo asigna
a formHilo.
}
public void detenerHilo()
{ //método para detener la ejecución del hilo.
continuar = false;
}
@Override //se sobrescribe el método run
@SuppressWarnings("SleepWhileInLoop")
public void run()
{
while (continuar) { //hágase mientras continuar sea
verdadero
try {
int avance = (int) (Math.random() * 4); //establece el avance
de jugador 1
formHilo.moverJugador1(avance); //invoca al método
moverJugador1 que se encuentra en el formulario FormaHilos
continuar = formHilo.seguir; //para validar si
se debe continuar.
Thread.sleep(150); //descansa por 15
segundos...
} catch (InterruptedException ex) {
System.out.checkError();
}
}
}
}

4. Código: clsJugador2.
package Logica;
import javax.swing.JOptionPane;
public class clsJugador2 extends Thread{
private int numero;
private String nombre;
private boolean continuar = true;
public clsJugador2() {
numero = 2; //le asigna el numero 2 al jugador 2.
nombre = JOptionPane.showInputDialog(null,"Digite el nombre del Jugador
2.");
}
public int getNumero(){return numero;} //para devolver el numero del
jugador
public String getNombre(){return nombre;}
public Fisica.FormaHilos formHilo; //declara una variable de tipo
FormaHilos
public clsJugador2(Fisica.FormaHilos aThis) { //constructor que recibe por
formHilo = aThis; //defecto el formulario FormaHilos y lo asigna a formHilo.
}
public void detenerHilo(){ //método para detener la ejecución del hilo.
continuar = false;
}
@Override //se sobrescribe el método run
public void run()
{
while (continuar) { //hágase mientras continuar sea verdadero
try {
int avance = (int) (Math.random() * 4); //establece el avance de jugador
2
formHilo.moverJugador2(avance); //invoca al método moverJugador2 que se
//encuentra en el formulario FormaHilos
continuar = formHilo.seguir; //para validar si se debe continuar.
Thread.sleep(150); //descansa por 15 segundos...
} catch (InterruptedException ex) {
} //Fin catch
} //Fin try
} //Fin método Run
} //Fin de la clase

5. Código: clsJugador3.
package Logica;
import javax.swing.JOptionPane;
public class clsJugador3 extends Thread {
private int numero;
private String nombre;
private boolean continuar = true;
public clsJugador3() {
numero = 3; //le asigna el numero 3 al jugador 3.
nombre = JOptionPane.showInputDialog(null,"Digite el nombre del Jugador
3.");
}
public int getNumero(){return numero;} //para devolver el numero del
jugador
public String getNombre(){return nombre;}
public Fisica.FormaHilos formHilo; //declara una variable de tipo
FormaHilos
public clsJugador3(Fisica.FormaHilos aThis) { //constructor que recibe por
formHilo = aThis; //defecto el formulario FormaHilos y lo asigna a formHilo.
}
public void detenerHilo(){ //método para detener la ejecución del hilo.
continuar = false;
}
@Override //se sobrescribe el método run
public void run()
{
while (continuar) { //hágase mientras continuar sea verdadero
try {
int avance = (int) (Math.random() * 4); //establece el avance de jugador
1
formHilo.moverJugador3(avance); //invoca al método moverJugador3 que se
//encuentra en el formulario FormaHilos
continuar = formHilo.seguir; //para validar si se debe continuar.
Thread.sleep(150); //descansa por 15 segundos...
} catch (InterruptedException ex) {
} //Fin catch
} //Fin try
} //Fin Run
} //Fin clase

6. Una vez que se ha escrito el código para las tres clases que procesarán a cada
jugador, proceda a escribir el código que radicará en el formulario principal
(FormaHilos.Java) Dicho código es el siguiente:
package Fisica;
import Logica.clsJugador1;
import Logica.clsJugador2;
import Logica.clsJugador3;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
public class FormaHilos extends javax.swing.JFrame {
javax.swing.table.DefaultTableModel modeloTabla = new
javax.swing.table.DefaultTableModel();
javax.swing.table.DefaultTableModel modTablaJugador1 = new
javax.swing.table.DefaultTableModel();
javax.swing.table.DefaultTableModel modTablaJugador2 = new
javax.swing.table.DefaultTableModel();
javax.swing.table.DefaultTableModel modTablaJugador3 = new
javax.swing.table.DefaultTableModel();
Object[] filas = new Object[24];
Object[] datosJugador1 = new Object[3]; //columnas celdaAvance,
Object[] datosJugador2 = new Object[3];
Object[] datosJugador3 = new Object[3];
public Boolean seguir = true;
int celdaJugador1=0;
int celdaJugador2=0;
int celdaJugador3=0;
int p=0;int q=0; int m=0;
//Se instancias las clases que están en otro paquete (Logica)
clsJugador1 jug1 = new clsJugador1();
clsJugador2 jug2 = new clsJugador2();
clsJugador3 jug3 = new clsJugador3();
public FormaHilos() {
initComponents();
//Creamos los componentas Tipo Etiqueta
JLabel
Nombre1=lblNombreJug1,Nombre2=lblNombreJug2,Nombre3=lblNombreJug3;
cargarTabla();
//Creamos las etiquetas y le damos formato de fuente y tamaño
Nombre1.setText("Jugador : "+jug1.getNombre().toUpperCase());
Nombre1.setFont(new java.awt.Font("Comic Sans MS", 0, 14));
Nombre2.setText("Jugador "+jug2.getNombre().toUpperCase());
Nombre2.setFont(new java.awt.Font("Comic Sans MS", 0, 14));
Nombre3.setText("Jugador : "+jug3.getNombre().toUpperCase());
Nombre3.setFont(new java.awt.Font("Comic Sans MS", 0, 14));

7. }
void cargarDetalle() {
for (int i=0;i<24;i++){
filas[i]=0; }
for(int x=1;x<=3;x++){
int numero = (int) (Math.random()*22+1); //para generar los
numeros.
filas[numero]= -1; }
modeloTabla.addRow(filas); //carga el modelo con los datos
obtenidos
Tabla.setModel(modeloTabla); //carga el modelo en JTab
//tabEmpleados
}
private void cargarTabla(){
for (int i=1;i<=24;i++){
modeloTabla.addColumn(String.valueOf(i)); }
cargarDetalle();
}
public void limpiarTabla(javax.swing.JTable miTabla)
{
DefaultTableModel modelo = (DefaultTableModel)
miTabla.getModel();
while(modelo.getRowCount()>0)
modelo.removeRow(0);
celdaJugador1=0;
celdaJugador2=0;
celdaJugador3=0;
seguir = true;
}
void confTablaJugadores(javax.swing.table.DefaultTableModel Modelo)
{
Modelo.addColumn("Celda Avance");
Modelo.addColumn("Contenido de la Celda");
Modelo.addColumn("Celda Actual");
}
public void moverJugador1(int celda) {
try{
celdaJugador1+=celda;
if (celdaJugador1 >= 24 && seguir == true )
{
celdaJugador1=24;
seguir = false;
JOptionPane.showMessageDialog(null, "Juego Terminado...Ganó el Jugador
No."+String.valueOf(jug1.getNumero()) +", " +
jug1.getNombre().toUpperCase());
} //aqui gana el jugador...
if (celdaJugador1 <= 24) {
Object valorCelda = Tabla.getValueAt(0,celdaJugador1);
if ( "-1".equals(valorCelda.toString())) celdaJugador1 = 0;
if (p == 0) {confTablaJugadores(this.modTablaJugador1);p=1;}

8. datosJugador1[0]=String.valueOf(celda);
datosJugador1[1]=valorCelda;
datosJugador1[2]=celdaJugador1;
modTablaJugador1.addRow(datosJugador1);
tablaJugador1.setModel(modTablaJugador1);
JLabel Jugad1=lblJugador1;
Jugad1.setText("Interacciones:
"+String.valueOf(modTablaJugador1.getRowCount()));
Jugad1.setFont(new java.awt.Font("Comic Sans MS", 0, 14));
}
} catch (Exception ex){
System.out.printf(ex.getMessage());
seguir = false;
}
}
public void moverJugador2(int celda) {
try{
celdaJugador2+=celda;
if (celdaJugador2 >= 24 && seguir == true ) {
celdaJugador2=24;
seguir = false;
JOptionPane.showMessageDialog(null, "Juego Terminado...Ganó el Jugador
No."+String.valueOf(jug2.getNumero()) +
", " + jug2.getNombre().toUpperCase());
} //aqui gana el jugador...
if (celdaJugador2 <= 24) {
Object valorCelda = Tabla.getValueAt(0,celdaJugador2);
if ( "-1".equals(valorCelda.toString()))
celdaJugador2 = 0;
if (q == 0) {
confTablaJugadores(this.modTablaJugador2);q=1;}
datosJugador2[0]=String.valueOf(celda);
datosJugador2[1]=valorCelda;
datosJugador2[2]=celdaJugador2;
modTablaJugador2.addRow(datosJugador2);
tablaJugador2.setModel(modTablaJugador2);
JLabel Jugad2=lblJugador2;
Jugad2.setText("Interacciones:
"+String.valueOf(modTablaJugador2.getRowCount()));
Jugad2.setFont(new java.awt.Font("Comic Sans MS", 0, 14));
}
} catch (Exception ex){
System.out.printf(ex.getMessage());
seguir = false; }
}
public void moverJugador3(int celda) {
try{
celdaJugador3+=celda;
if (celdaJugador3 >= 24 && seguir == true ) {

9. celdaJugador3=24;
seguir = false;
JOptionPane.showMessageDialog(null, "Juego Terminado...Ganó el Jugador
No."+String.valueOf(jug3.getNumero()) +
", " + jug3.getNombre().toUpperCase());
} //aqui gana el jugador
if (celdaJugador3 <= 24) {
Object valorCelda = Tabla.getValueAt(0,celdaJugador3);
if ( "-1".equals(valorCelda.toString())) celdaJugador3 = 0;
if (m == 0) {confTablaJugadores(this.modTablaJugador3);m=1;}
datosJugador3[0]=String.valueOf(celda);
datosJugador3[1]=valorCelda;
datosJugador3[2]=celdaJugador3;
modTablaJugador3.addRow(datosJugador3);
tablaJugador3.setModel(modTablaJugador3);
JLabel Jugad3=lblJugador3;
Jugad3.setText("Interacciones:
"+String.valueOf(modTablaJugador3.getRowCount()));
Jugad3.setFont(new java.awt.Font("Comic Sans MS", 0, 14));
}
} catch (Exception ex)
{
System.out.printf(ex.getMessage());
seguir = false;
}
}
Código botón btnReiniciarJuego
private void btnReiniciarJuegoActionPerformed(java.awt.event.ActionEvent
evt) {
// TODO add your handling code here:
limpiarTabla(this.tablaJugador1);
limpiarTabla(this.tablaJugador2);
limpiarTabla(this.tablaJugador3);
btnJugar.setEnabled(true);
btnReiniciarJuego.setEnabled(false);
lblJugador1.setText("Interacciones: 0");
lblJugador2.setText("Interacciones: 0");
lblJugador3.setText("Interacciones: 0");
}

10. Código botón btnGenerarTabla
private void btnGenerarTablaActionPerformed(java.awt.event.ActionEvent
evt){
// TODO add your handling code here:
modeloTabla.removeRow(0);
Tabla.setModel(modeloTabla);
cargarDetalle();
}
Código botón btnJugar
private void btnJugarActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
clsJugador1 j1;
j1 = new clsJugador1(this);
clsJugador2 j2;
j2 = new Logica.clsJugador2(this);
clsJugador3 j3;
j3 = new Logica.clsJugador3(this);
j1.start();
j2.start();
j3.start();
if (seguir == false)
{
j1 = null;
j2 = null;
j3 = null;
}
btnJugar.setEnabled(false);
btnReiniciarJuego.setEnabled(true);
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
new FormaHilos().setVisible(true);
} //Fin Run
});
} //Fin Main

11. CONCLUSIÓN
BALAM YAM WILBERTH:
En esta cuarta unidad abarcamos el tema de la programación en hilos o
programación concurrente, que nos ayuda a que nuestro software realice varias
tareas “Simultáneamente”. Y eso nos puede resolver varios problemas en el
desarrollo de software.
POOT TUZ EFRAIN ANTONIO
En la unidad cuatro vimos lo que son los hilos los hilos en java son básicamente en
forma para poder ejecutar varios procesos simultáneamente en nuestros programas
en java para poder ver o crear los hilos tenemos que crear una clase Thread o
reescribir el método principal “rum()”” el cual se va a ejecutar principalmente al inicial
un hilo, Thread o un nuevo proceso en java.
AYALA MUTUL EZER ABISAI
En la unidad cuatro se desarrolló una aplicación de escritorio, donde se aplicó el
funcionamiento de packages que vimos en la unidad anterior, igual vimos cómo
aplicar como aplicar el funcionamiento de hilos esto nos ayudara al manejo de
varias tareas simultaneas.
AKE PECH JORGE MANUEL
Aprendimos a hacer programación en hilos en la cual son procesos independientes
en la cual se está ejecutando programas. Y eso nos ayuda mucho en el momento
de desarrollar un software.
CHABLE PAT JHONNY GABRIEL
En esta unidad realizamos algunas prácticas con los multihilos y aprendimos que
los hilos son un conjunto de acciones independientes que se activan durante la
ejecución de un programa. Que son útiles cuando se necesitan realizar varias
acciones a la vez de manera organizada sin afectar otras funciones en un programa.
Lo mejor que hemos aprendido en esta unidad es saber implementar los hilos en
nuestros programas, para realizar diferentes acciones determinadas. Y para
finalizar, aprendimos a utilizar el código que se utiliza.
VEGA SEGURA ADRIÁN ASÍS
En esta unidad vimos lo que la programación concurrente y su utilidad en el
software. Podemos decir que un programa multi hilo contiene dos o más partes que
pueden ejecutarse de forma concurrente. El programa contiene hilos que viene
siendo como caminos con su propio código. Se puede ejecutar paras hilos a la vez

12. pero es muy diferente a los procesos porque los procesos son independientes y los
hilos forman parte de un solo programa.