UNA CLASE JAVA CON DOS O MAS HILOS

Para poder tener dos metodos run en una misma clase es necesario heredar de thread o implementar runnable el ejemplo de como quedaria la clase seria el siguiente

public class ClaseConMultiplesHilos implements Runnable {

/* constructor */
ClaseConMultiplesHilos(){ }

//primer metodo run
public void run(){ }

//segundo metodo run
Thread hilo2 = new Thread() {
public void run() { }
//contenido del hilo2
};

hilo2.start();
//puede haber mas hilos...

}

en realidad un metodo run esta dentro de otra funcion, pero la cosa esta si sirve.

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de ezamudio

segundo run()

El segundo método run() pertenece a una clase anónima interna de ClaseConMultiplesHilos.

Mmh en cierto sentido tu

Mmh en cierto sentido tu clase ClaseConMultiplesHilos si tiene dos métodos run, aunque el segundo no le pertenece a esa clase, sino a su clase interna.

Si quieres tener dos método run o cualquier otro , lo que tienes que hacer es sobrecargarlos aunque solamente uno de ellos será especial en el contexto de Threads y el otro, pues solamente estará ahí de soporte.

class ClaseConMultiplesHilos {
     public void run() {
          // primer run
      }
      public void run( int i ) { // int o String o Object o cualquier otro parámetro
           // segundo run
      }
}

Ahora si, ya tienes dos métodos run dentro de una misma clase.

Imagen de skuarch

Si es cierto !!!

el segundo run pertenece a una clase interna Thread, al final del post puse que es de otra funcion pero no es de otra clase.

la cuestion es que a mi si me srive cuando quiero tener dos hilos en una clase y se los comparto por si a alguien no se le ocurrio.

A proposito OscarRyz el segundo metodo no es un hilo, en efecto solo es sobre carga

Imagen de jali

Diferencias en los conceptos @OscarRyz

Creo que aquí hay un malentendido ya que tu mencionas que pertenece a una clase interna y no es asi. (en cuestion de terminos, ya que Java maneja una clase interna de otra forma)
Voy a entrar un poco en detalle describiendo esto ya que en java existen las clases anidadas y estas se dividen en 2 tipos:
Anidadas e Internas
Clases Anidadas
Una clase anidada es una clase que esta dentro de una clase y es estatica, esto es por que la manera en la que se instancian es la siguiente:

ClaseTop.ClaseAnidada nested = new ClaseTop.ClaseAnidada();

desde linea de comandos puedes escribir: java ClaseTop$ClaseAnidada

Clases Internas
Una clase interna es una clase que esta dentro de una clase y no es estatica. Este tipo de clases no pueden ser invocadas de la misma forma que las anidadas. Para instanciar una clase interna se usa lo siguiente:

Clase.ClaseInterna inner = clase.new ClaseInterna();

Aquí dejo un ejemplo de una clase con estos tipos de clase:

package test;

/**
 *
 * @author Jali
 */

public class Clase {
    private static final int a = 1;
    public static void main(String[] args) {      
        Clase clase = new Clase();
        clase.print();
        //Clase Interna Anonima
        clase = new Clase(){
            int a = 2;
            public void print(){
                System.out.println("clase anonima interna");
            }
        };
        clase.print();
       
        Clase.ClaseInterna inner = clase.new ClaseInterna();
        inner.print();
    }
    //Clase Anidada
    public static class ClaseAnidada{
        public static void main(String[] args) {
            System.out.println("Wow! estoy mandando a llamar mi propio main!!!?");
        }
    }
    //Clase Interna
    class   ClaseInterna{
        public void print(){
            System.out.println("ClaseInterna: print()");
        }
    }
    public void print(){
        System.out.println("top level print");
    }
}

Y que pasaria si lo mandamos llamar? java test.Clase? pues la salida seria :

top level print
clase anonima interna
ClaseInterna: print()

Y que pasaria si lo mandamos llamar? java test.Clase$ClaseAnidada? pues la salida seria :
Wow! estoy mandando a llamar mi propio main!!!

Ahora, el tipo de clase que comenta enrique es una clase anonima y por que se llama asi? simplemente por que no tiene nombre. En el ejemplo anterior vemos como esta definicion es muy similar a lo que se indica en el problema:

Thread hilo2 = new  Thread() {
public void run() { }
//contenido del hilo2
};
clase = new Clase(){
    int a = 2;
    public void print(){
        System.out.println("clase anonima interna");
    }
};

Un uso muy comun en las clases anonimas es el siguiente:

addWindowListener( new WindowAdapter() {
   public void windowOpened( WindowEvent e ){
        field1.requestFocus();
     }
   public void windowClosing( WindowEvent e ){
     if (field1.getText().equals("yes")) {
        if (JOptionPane.showConfirmDialog
             (null,"Are you sure ?")==JOptionPane.YES_OPTION) {
           setVisible(false);
           dispose();
           }
        }
     }
   } );

Saludos
Alejandro

Imagen de fcodiaz

Se me ocurre algo loco...

y que tal si agregamos una propiedad que sea del tipo de la clase que estas definiendo, con una clase recursiva xP.. o anidada como lo menciona @jali anque alli mas bien tendrias muchos Objetos de la misma dentro que los contiene xD, la recursividad es algo loco xP... pero si como dice @ezamudio , lo que estas creando es un objeto abstracto y le refines su run, ese run no es de tu clase ClaseConMultiplesHilos, la unica forma de tener dos metodos con el mismo nombre en el mismo objeto es con sobrecarga lo que comenta @OscarRyz pero creo que eso no es lo que buscabas lograr, mas bien entiendo yo.. en una misma clase correr varios hilos de la misma.. ps eso con recursividad en clases se podria lograr, creo yo!, la neta nunca he hecho un hilo :$

Ahhhhhhh.... pues es que

Ahhhhhhh.... pues es que jamás dijiste que querías tener dos Threads.

Haberlo dicho antes. Supongo que en tu mente al escribir: "Una clase con dos metodos run" querías decir: "Una clase con dos hilos?" ...

Ahora queda claro. Efectivamente, lo que yo puse es solo para tener dos metodos que se llamen run.

Lo que tu haces es para tener dos hilos.

A ver si te entendí bien, lo que haces es que al crear una instancia de esta clase puedes potencialmente ejecutar dos hilos a la vez?

Thread t = new Thread( new ClaseConMultiplesHilos() );
t.start();

Ahh vaya. Si ese es el caso, lo unico que sería recomendable es mover la creación del Thread 2 detro del run, al menos para que empiecen al mismo tiempo. Pues si el segundo thread empieza apenas crees la instancia:

ClaseConMultiplesHilos ccmh = new ClaseConMultiplesHilos();

// el thread ya empezo.

// algunos "instantes" despues:

( new Thread( ccmh ) ).start(); // el otro ya lleva ventaja.

Bien! :P

Imagen de klone

Hola!

Hola que tal pues si mal no me desvio del tema estq podria ser una buena forma de controlar multihilos

Tener una Clase que contenga las referencias de los demas hilos a esta le llamaremos HiloMadre y la cual echara a andar los demas hilos (es algo parecido a lo que hace php creando un folk) la diferencia es que en esta no perdemos la referncia a los hilos

import java.util.HashMap;
import java.util.Iterator;

/**
 *
 * @author root
 */

public class HiloMadre extends Thread {

    @Override
    public synchronized void start() {
        super.start();
    }
    private HashMap<String, HiloInterface> ListaHilos=new HashMap<String, HiloInterface>();

    @Override
    public void run() {
        System.out.println("MAMA CORRIENDO");
        HiloHijo h = new HiloHijo();
        agregarHilo("h1", h);
        h.start();
    }

    private void agregarHilo(String s, HiloInterface t) {

        ListaHilos.put(s, t);
    }

    public Iterator<String> getNombreHilos() {
        java.util.Iterator<String> it = ListaHilos.keySet().iterator();
        return  it;
    }

    public void pararHilo(String s) {
        //  System.out.println(ListaHilos);
        ListaHilos.get(s).parar(true);
    }
}

como se puede ver en la clase se utiliza otra clase llamada HiloInterface la cual solo nos proove de metodos para acceder al hilo hijo

public interface HiloInterface {

    public abstract  void parar(boolean  b);
}

Y por ultimo la clase hijo que necesita implementar HiloInterface

import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author root
 */

public class HiloHijo extends Thread implements HiloInterface {

    boolean bol = true;

    @Override
    public void run() {

        while (bol) {
            System.out.println("hilo1 corriendo");
            try {
                sleep(1000);
            } catch (InterruptedException ex) {
               ex.printStackTrace();
            }
        }
    }

    public void parar(boolean b) {
        this.bol = false;
    }
}

y claro que no puede faltar el main

import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author root
 */

public class Main {

    /**
     * @param args the command line arguments
     */

    public static void main(String[] args) {
        // TODO code application logic here
        HiloMadre m = new HiloMadre();
        m.start();
        try {
            m.sleep(1000);
        } catch (InterruptedException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }
     //   m.agregarHilo("h1");
        m.pararHilo("h1");
    }
}

OJO aqui se pone a dormir 1 segundo la madre por ke el hilo hijo tarda 1 segundo en ejecutarse

y asi se podria obtener un buen control sobre los hilos SALUDOS :D

@Jali: Caasi...

Mmhhh casi.

A ver según esto: Nested classes

La terminología es la que sigue:

Las clases anidadas, están divididas en dos categorías: estáticas y no-estáticas. Las clases anidadas que son declaradas como estáticas son llamadas simplemente classes estáticas anidadas. Las clases anidadas, no-estáticas, son llamadas, clases internas

Y como la clase definida en:

...= new Thread() {
           public void run() {
           }
    };

no es estática, luego entonces es no-estática, y como es no-estática, se le puede llamar clase interna.

Ahora que además de interna sea anonima, si!, es correcto, ahi tienes tooooooda la razón, debí haber escrito clase anónima interna ( como Enrique ) , aunque el que sea anónima eso no le quita su carácter de interna.

Entonces, tendríamos.

+Nested Classes
 +---Static nested classes
 +---Inner classes
       +---anonymous inner classes  
Imagen de skuarch

Corregido !!!

ya corregi el titulo del post !!!

Imagen de jali

Pool de hilos

Para hacer esto podrias echarle un ojo a esta liga. Puedes manejar un determinado numero de hilos(pool de hilos) esto te puede servir para por ejemplo limitar el numero de conexiones concurrentes a un servidor o evitar que tu cliente haga un ataque de DoS jejeje. Liga aqui
PD Esto lo conoci gracias a @ezamudio en una charla de la comunidad.

Saludos!

Imagen de jali

@OscarRyz

Si, pero al fin y al cabo son definiciones distintas.(eso es lo que queria decir) ya que esa clase sigue siendo anonima debido a que no tiene nombre. Una clase interna puede tener nombre. Esto lo mencionaba ya que en el examen de certificacion lo preguntan puntual, nomas era para aclarar este punto y por esto escribi:

Creo que aquí hay un malentendido ya que tu mencionas que pertenece a una clase interna y no es asi. (en cuestion de terminos, ya que Java maneja una clase interna de otra forma)

y tambien mencionar que en la liga que envias viene definido de esta forma:

class OuterClass {
    ...
    static class StaticNestedClass {
        ...
    }
    class InnerClass {
        ...
    }
}

Cabe aclarar que esto es unicamente en base a los conceptos como mencione anteriormente.

Saludos y gracias por la retroalimentacion