Escriba un programa que escriba simultaneamente
dos tipos de caracteres. Debe imprimir 1000 veces 
cada caracter y para ello Ud debe implementar:

1 Una clase de tipo thread que reciba como parametro
  el tipo de caracter que debe imprimir.

2 Crear un metodo denominado run que imprima 1000 veces
  el caracter especificado para esta clase.

3 Crear el metodo main que tenga dos instancias de la 
  clase que hereda de thread e  indicarles que 
  comienzen su ejecucion.

-------------------------------------------

Solucion:

public class caracter extends Thread{
    char c;
    public caracter(char c){
        this.c=c;
    }
    
    public void run(){
      for(int i=0;i<1000;i++){
        System.out.print(c);
        if(i%40==0)
          System.out.println();
      }
    }

    public static void main(String [] args){
       caracter a,b;
       a=new caracter('a');
       b=new caracter('b');
       a.start();
       b.start();
    }
}



-------------------------------------------


Se desea simular un hipodromo. Para ello se le solicita
que cree una clase denominada caballo cuyo constructor
reciba el nombre del caballo.
Cada caballo se debe demorar un tiempo random entre 
[1000,9999] milisegundos en terminar la carrera y al
hacerlo debe imprimir: "caballo <nombre> termino en: 
<tiempo>". La espera por el tiempo debe ser real e 
implementado de forma eficiente.
Luego ud debe implementar el metodo main que
cree 10 caballos y los haga correr.

-------------------------------------------

Solucion:

public class caballo extends Thread{

    public caballo(String name){
        super(name);
    }
    public void run(){
        int time=(int)(Math.random()*9000+1000);
        try{
          sleep(time);
        }
        catch(InterruptedException e){
          System.out.println("Caballo "+getName()+ " interrumpido.");
        }
        System.out.println("Caballo "+getName()+ " termino en: "+time);
    }

    public static void main(String [] args){
       caballo [] caballos = new caballo[10];
       for(int i=0;i<10;i++)
          caballos[i]=new caballo(""+i);
       for(int i=0;i<10;i++)
          caballos[i].start();
    }
}

-------------------------------------------

Escriba un programa que realice una busqueda binaria en arreglos
mediante 4 threads. Cada thread debe buscar en una zona distinta 
del arreglo. Si el arreglo es de menos de 4 elementos, debe
crearse un unico thread que realice la busqueda. Se debe ejecutar
el programa con el siguiente encabezado:

  java busquedaThread 6 -1 0 1 2 3 4 4

Donde el primer parametro es el largo del arreglo, luego vienen
los elementos del arreglo y finalmente el numero a buscar.
Si el elemento buscado se encuenrta dentro del arreglo, se debe 
imprimir en pantalla:

  Element <elemento> found by thread <numero de thread> at position 
  <posicion dentro del arreglo>

En el caso del ejemplo deberia ser:

 Element 4 found by thread 4 at position 5

En caso que no se encuentre, el programa no debe entregar informacion.

Nota: solo por esta vez, asuma que los parametros son ingresados
correctamente, es decir, todos son numeros y la informacion es 
consecuente.

-------------------------------------------

class busquedaThread extends Thread{
  int [] array;
  int start,end,element;

  public busquedaThread(int [] a,int start, int end,String name){
    super(name);
    array=a;
    this.start=start;
    this.end=end;
    element=0;
  }

  public void setElement(int element){
    this.element=element;
  }

  public void run(){
    int pos=finder(start,end);
    if(pos!=-1)
      System.out.println("Element "+element+" found by thread "+getName()+
                          " at position "+pos);
  }

  protected int finder(int s, int e){
    int middle=(s+e)/2;
    int pivote=array[middle];
    if(pivote==element)
      return middle;
    else if(s==e)
      return -1;
    else if(pivote<element)
      return finder(middle,e);
    else
      return finder(s,middle);
  }

  public static void main(String [] args){

    //obtener largo
    int length=Integer.parseInt(args[0]);

    //crear arreglo
    int [] array = new int[length];

    //poner info
    for(int i=0;i<array.length;i++)
      array[i]=Integer.parseInt(args[i+1]);

    //ver cuantos threads se necesitan:
    int step=length/4;

    //Crear un unico thread cuando hay
    //menos de 4 elementos

    if(step==0){
      busquedaThread bt1 = new busquedaThread(array,0,length-1,"1");
      bt1.setElement(Integer.parseInt(args[length+1]));
      bt1.start();
      return;
    }
 
    //Crear los threads
    busquedaThread [] bt = new busquedaThread[4];
    for(int i=0;i<3;i++)
      bt[i]= new busquedaThread(array,i*step,(i+1)*step-1,""+i);

    bt[3] = new busquedaThread(array,3*step,length-1,"4");

    //indicar el elemento a buscar
    for(int i=0;i<4;i++)
      bt[i].setElement(Integer.parseInt(args[length+1]));
    
    //comenzar los threads
    for(int i=0;i<4;i++)
      bt[i].start();
    
  }
}
