Mostrando entradas con la etiqueta Hilos. Mostrar todas las entradas
Mostrando entradas con la etiqueta Hilos. Mostrar todas las entradas

viernes, 4 de abril de 2014

Ejercicios Básicos de Concurrencia en Java (Parte 1/3)

Buenas gente. Hoy os traigo ejercicios de lo más básico para practicar la concurrencia en Java.
Aquí os dejo el enunciado de los dos primeros:

1. Realizar un programa en Java con 3 hebras, cada una de las cuales escribe por
pantalla varias veces (valor pasado como parámetro en el constructor) el carácter
que se le indique (también indicado como parámetro). ¿Se mezclan las letras?
Justifica el comportamiento observado.

b) Modificar el programa de la siguiente manera: se van a mostrar las letras A, B
y C. Para ello, utilizaremos 3 hebras como en el caso anterior, pero queremos
limitar la posible salida de caracteres por pantalla para que no se produzca de
cualquier forma sino con la secuencia indefinida: ABBCCC, esto es, por
ejemplo: ABBCCCABBCCCABBCCC...

Se recomienda la utilización de una variable compartida por las hebras que sirva
para asignar turnos, de manera que cada hebra imprime su letra cuando sea su
turno. De esta forma, cuando se crean las hebras, a cada una se le asigna un
identificador para que puedan comprobar cuando es su turno, y que mientras no
sea su turno, no hagan nada (ej: while (turno != miid) ; )

2. Disponemos de una clase denominada VariableCompartida que encapsula el
valor de una variable v de tipo int. La clase VariableCompartida contiene
métodos para establecer (método set), obtener (método get) o incrementar
(método inc) el valor de v. Realizar un programa en Java que cree 2 hebras
compartiendo una instancia de la clase VariableCompartida e incrementen
cada una de ella 10 veces el valor de v. Mostrar desde la hebra del programa
principal el valor final de v. ¿Se obtienen los resultados esperados? Aumenta
progresivamente el número de incrementos hasta observar algún
comportamiento “extraño”. Justifica los resultados obtenidos. 
Y aquí os dejo los resultados ;)

Primer Ejercicio:

   public class EscribirCaracter extends Thread {
        public volatile static int turno; 
 //static hace que el valor sea el mismo en todos los objetos
 //volatile hace que la variable turno sea compartida entre varias hebras
 private int veces;
 private char car;
 private int id;
 
 public EscribirCaracter(int v, char c, int i) {
  turno = 0;
  veces = v;
  car = c;
  id = i;
 }
 
 public void run() {
  while(turno!=id);
   for(int k = 0; k < veces; k++) {
    System.out.print(car);
   }
  
  turno = (turno+1)%3;
 }
 
 public static void main(String[] args) throws InterruptedException {
  EscribirCaracter h1, h2, h3;
  h1 = new EscribirCaracter(1, 'A', 0);
  h2 = new EscribirCaracter(2, 'B', 1);
  h3 = new EscribirCaracter(3, 'C', 2);
 
  h1.start();
  h2.start();
  h3.start();
  try {
   h1.join();
   h2.join();
   h3.join();
  } catch(InterruptedException e) {
   throw new InterruptedException();
  }
  
  
 }
}

Segundo ejercicio:

public class Incrementador extends Thread{
 
 private int vueltas;
 private VariableCompartida var;
 
 public Incrementador(int i, VariableCompartida v) {
  vueltas = i;
  var = v;
 }
 
 public void run() {
  for(int i = 0; i < vueltas; i++) {
   var.inc();
  }
 }
 
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  VariableCompartida variable = new VariableCompartida(0);
  Incrementador i1 = new Incrementador(1000, variable);
  Incrementador i2 = new Incrementador(1000, variable);
  
  i1.start();
  i2.start();
  
  try {
   i1.join();
   i2.join();
  } catch(InterruptedException e) {
   e.printStackTrace();
   
  }
  
  System.out.println(variable.get());
  
 }

}

Y la class VariableCompartida que es:

public class VariableCompartida {
 public static volatile int turno = 0;
 private int var;
 public VariableCompartida(int i) {
  var = i;
 }
 
 public void set(int i) {
  var = i;
 }
 public int get() {
  return var;
 }
 public void inc() {
  var++;
 }
 public static void incTurno() {
  turno = (turno+1)%2;
 }
 public static int getTurno() {
  return turno;
 }
}

Espero que hayais estado un rato entretenidos con los ejercicios. Estoy preparando otros más para subir :)

Saludos;)

miércoles, 2 de abril de 2014

Examen Programación de Sistemas y Concurrencia Curso 2013 (Parte de Java)

Buenas gente. Aquí me hallo preparando el examen de esta asignatura, que toca este jueves. Acabo de hacer el ejercicio de java del examen del 2013 y os lo traigo aquí.

Como siempre aquí teneis el enunciado y aquí la clase usada. Procedo a copiaros el enunciado:


Diseña un programa java que implemente un algoritmo de búsqueda de un número int valor en un array de enteros int[] vector de forma recursiva y concurrente. El programa debe construir un árbol binario de hebras, de profundidad variable, que depende del número de componentes de vector. El sistema sólo necesita una clase Nodo que se comporta como se describe a continuación.
 Inicialmente, el método main() crea un primer nodo (el nodo raíz del árbol) al que se le pasa un array vector de números aleatorios. Cada uno de los nodos que se vayan creando en el sistema se comporta de la misma forma. Si el vector que se le pasa al nodo en el constructor tiene 0 o 1 elementos, es trivial comprobar si el valor está en el array. En otro caso, la hebra crea dinámicamente dos nuevas hebras, y le pasa a cada una de ellas una de las dos mitades del vector. Una vez que cada hebra hija ha buscado el valor en su mitad, la hebra padre comprueba si valor estaba en alguna de las dos mitades, y devuelve el resultado correspondiente. Como ayuda para la implementación, se sugiere la siguiente estructura para el constructor de la clase Nodo y el método main:

public Nodo(int[] vector,int inic,int fin,int valor,boolean[] res){ 
// busca "valor" en vector[inic..fin-1] y deja el resultado en res[0] 
 .... 
} 
 
public static void main(String[] args){ 
 Random r = new Random(); 
 int[] vector = new int[r.nextInt(20)+1]; 
 for (int i = 0; i<vector.length; i++){ 
 vector[i] = r.nextInt(20); 
 } 
 int valor = r.nextInt(20); 
 System.out.println("Buscamos "+valor+" en "+Arrays.toString(vector)); 
 boolean[] res = new boolean[1]; 
 Nodo nodo = new Nodo(vector,0,vector.length,valor,res); 
 .... 
 
} 

La verdad es que no tengo ni idea de por qué te piden el booleano en un array, pero así lo pedían y así lo he hecho :P

Aquí teneis la class resuelta:

import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;


public class Nodo extends Thread{
 
 private int[] vector;
 private int inic, fin, valor;
 private static volatile boolean[] res;
 
 public Nodo(int[] vector,int inic,int fin,int valor,boolean[] res){ 
  // busca "valor" en vector[inic..fin-1] y deja el resultado en res[0] 
   this.vector = vector;
   this.inic = inic;
   this.fin = fin;
   this.valor = valor;
   this.res = res;
  } 
 
 public void run(){

  // Como la variable res es static, es la misma para todos los objetos
  // Además como es volatile, si cambia en un objeto se actualiza a todos.
  if(!res[0]) {
   
   if((fin-inic)>1) {
    //Creamos dos nodos para ver los valores.
    Nodo n1 = new Nodo(vector, inic, (inic+((fin-inic)/2)), valor, res );
    Nodo n2 = new Nodo(vector, (inic+((fin-inic)/2)), fin, valor, res );
    
    n1.start();
    n2.start();
    
    try {
     n1.join();
     n2.join();
    } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }    
    
   } else {
    if(vector[inic]==valor)
     res[0] = true;
   }
   
  }
  
 }
 
 
 
 
 
 
   
  public static void main(String[] args){ 
   Random r = new Random(); 
   int[] vector = new int[r.nextInt(20)+1]; 
   for (int i = 0; i<vector.length; i++){ 
   vector[i] = r.nextInt(20); 
   } 
   int valor = r.nextInt(20); 
   System.out.println("Buscamos "+valor+" en "+Arrays.toString(vector)); 
   boolean[] res = new boolean[1]; 
   Nodo nodo = new Nodo(vector,0,vector.length,valor,res); 
   
   nodo.start();
   
   try {
   nodo.join();
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
   
   System.out.println(res[0]);
   
   //Por si fallara, que se viera.
   Set<Integer> set = new HashSet<>();
   for(int i : vector) {
    set.add(i);
   }
   
   if(set.contains(valor) != res[0]) {
    System.out.println("ERROOOOOOOR");
   }
  } 
  

}
 
 
Bueno. Espero que comentéis si encontráis una forma mejor o si tenéis alguna duda.

Saludos ;)