Control de Threads avanzado

[Debci]

Miren amigos, quier hacer que mi thread se ejecute, haga su funcion, se pause que otro metodo recoja los datos, y que continue su funcionamiento, es decir que haga que me de datos y que continue, tengo lo siguiente:

Código (java) [Seleccionar] Expandir


//Esta clase se encarga de administrar y definir el comportamiento del proceso thread que refresca el
//y obtiene datos del servidor.

//Para ejecutar un thread ponemos new threadChat("Nombre del thread").start();
package procesos;

/**
*
* @author Andoni Diaz
*/
public class threadChat extends Thread {
    public static String datoObtenido;
    public static int contador;
    public threadChat(String str) {
        super(str);
    }
    public void run() {
    for(int i = 0; i < 10; i++) {
   
        datoObtenido = "Hola";
        contador=1;
        contador++;
       
            }
    }
    public static void main(String args[]) {
       threadChat thread = new threadChat("Prueba");
       thread.setPriority(10);
       thread.start();
       thread.stop();
        System.out.println(datoObtenido + contador);
    }
}


Cuando puedo pararlo y recobrar la ejecucion?

Saludos

[kinos]

Lo que puedes hacer es lo siguiente. Utilizas un hilo para hacer una tarea de generar datos por ejemplo y los vas guardando en una pila o una cola. Luego desde otro hilo los vas recuperando y haces otra tarea. Es como en este esquema:

|Hilo A|   --> Pila o cola <-- |Hilo B|

Así no tendrías la necesidad de pararlos nunca. Cuando no hay datos, Hilo B se queda esperando. Cuando hilo A añade datos despiertas con el metodo notifyAll() por si Hilo B esta esperando...
Y asi...

Si quieres parar los procesos. La gente no lo recomienda hacer mediante thread.stop(); porque no sabes en que punto se va ha quedar y si te puede generar problemas... Entonces te sugiero que utilices dentro del metodo run() de tu thread alguna artimaña.

Por ejemplo:

Código (java) [Seleccionar] Expandir


public void run() {
   while(estadoDeMiHilo){//mientras no haya que salir
    for(int i = 0; i < 10; i++) {

        datoObtenido = "Hola";
        contador=1;
        contador++;

            }
    }
      if(estadoDeMiHilo==pausa){
        wait();
      }
   }


Te recomiendo que leas mucha info y vayas haciendo ejemplos sencillos y una vez que tienes la estructura que quieres comienza a hacer tu programa.

[Leyer]

como dice kinos no puedes usar el stop pero si podrias usar un identificador

si quieres que el hilo haga su tarea luego continue ya las condiciones seran las tuyas pero este es un ejemplo modificando tu code.

Código (java) [Seleccionar] Expandir


/**
*
* @author Andoni Diaz
*/
public class threadChat extends Thread {
    private     String datoObtenido;
    private int contador =0;
    private boolean run = true;
    public threadChat(String str) {
        super(str);
    }
    public boolean isRun() {
return run;
}
public void setRun(boolean run) {
this.run = run;
}
public synchronized void run() {
    while(run){
        datoObtenido = "Hola";
        System.out.println(datoObtenido+" ->"+contador);
        contador++;
        try {
    wait();
      } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
        }
    }System.out.println("Hilo Detenido");}
    public static void main(String args[]) {
       threadChat thread = new threadChat("Prueba");
       thread.setPriority(10);
       thread.start();
       int max = 10;
       while(true){
        try {
Thread.sleep(500);
} catch (InterruptedException e) {e.printStackTrace();
}
synchronized (thread) {
thread.notify();
if(thread.contador==max)
thread.setRun(false);
   }
       }
    }
}

[Debci]

La cosa esta en que aunque arranque dos threads, primero se ejecuta uno y luego otro, no funcionan como rpocesos de ejecucion paralela, son mas bien como dos metodos , primero se ejecuta y luego el otro.

Es algo contradictorio a lo que he leido por ahi ya que dicen que se ejecutan ambos  ala vez y van haciendo cada uno por su lado, es decir, que el programa arranca el primeor y continua su proceso principal mientra el thread arrancado va trabajando, pero mi experimentación no dice eso.

Saludos

[Leyer]

veamos tu quieres o dices como lo planteaste en tu problema que el primer Hilo-1 este haciendo la tarea "A" si completo la tarea este se coloca en modo de espera.luego el segundo Hilo-2 entra en el Hilo-1 y optiene la tarea "A"luego el Hilo-1 Continua haciendo su tarea y el Hilo-2 espera aque se procese una nueva tarea eso eso lo planteas..?

[Debci]

veamos tu quieres o dices como lo planteaste en tu problema que el primer Hilo-1 este haciendo la tarea "A" si completo la tarea este se coloca en modo de espera.luego el segundo Hilo-2 entra en el Hilo-1 y optiene la tarea "A"luego el Hilo-1 Continua haciendo su tarea y el Hilo-2 espera aque se procese una nueva tarea eso eso lo planteas..?

En teoria si, solo que yo tenia entendido que se podian ejecutar dos al mismo tiempo, pero asi me vale xD

Saludos

[Leyer]

yo diria que no es necesario eso de correrlos al mismo tiempo pero bueno. me extraña de que no sepas hacerlo como dices. este que yo hice seria lque se adapta perfecto a lo que dice Kinos  claro tu veras que tareas le pones   

-------------------------------------------------------------------------------
-----------------------------------
:Performing the task : 0
-----------------------------------

Thread Control->Obtained:Task 1
->Restarting..Thread For Tasks
-----------------------------------

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

Código (java) [Seleccionar] Expandir


/**
*
* @author L-eyer
*/
class mainClass{
//---------------------------------------------------
public static void main(final String[] args){
threadForTasks tasks = new threadForTasks();
new ThreadControl(tasks);
tasks.start();
}
}
class threadForTasks extends Thread{
private int     task     = 0    ;
private boolean active   = true ;
private boolean received = false;

public int  getTask() {return task;}
public void setTask(int index) {this.task = index;}

@Override public synchronized void run(){
while(active){
try {
Thread.sleep(500);
} catch (InterruptedException e) {e.printStackTrace();
}
System.out.println("-----------------------------------");
System.out.println(":Performing the task : "+task);
System.out.println("-----------------------------------");
task++;
received = true;
try {
wait();
} catch (InterruptedException e1) {e1.printStackTrace();
}
}
}
public boolean isReceived() {
return received;
}
public void setReceived(boolean received) {
this.received = received;
}
public threadForTasks() {super("Thread For Tasks");
}
}
        public class ThreadControl extends Thread{
private threadForTasks thread;
private boolean activated  = true ;
@Override public synchronized void run(){
while(activated){
try {if(thread.isReceived()){
       System.out.println("\n"+getName()+"->Obtained:Task "+thread.getTask()+"");
synchronized(thread){
System.out.println("->Restarting.."+thread.getName());
Thread.sleep(1000);
       thread.setReceived(false);
thread.notify();
}
}
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}
public boolean isActivated() {
return activated;
}
public void setActivated(boolean activated) {
this.activated = activated;
}
public ThreadControl(threadForTasks threadNro1) {super("Thread Control");
this.thread = threadNro1;
start();
}
}
Saludos..

[Debci]

Bien ya he probado el concepto que me proponeis, pero no funciona, por mi falta de planteamiento, que es lo mas probable:

Código (java) [Seleccionar] Expandir


//Esta clase se encarga de administrar y definir el comportamiento del proceso thread que refresca el
//y obtiene datos del servidor.

//Para ejecutar un thread ponemos new threadChat("Nombre del thread").start();
package procesos;

import java.io.IOException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;


/**
*
* @author L-eyer
*/
public class threadChat extends Thread {
    private String datoObtenido;
    public static threadChat thread;
    private int contador =0;
    private int dummie = 0;
    public int dummieFinal = 0;
    public static ThreadRecojida threadLectura;
    private boolean run = true;
    public threadChat(String str) {
        super(str);
    }
    public boolean isRun() {
return run;
}
public void setRun(boolean run) {
this.run = run;
}
public synchronized void run() {
    while(run){
        datoObtenido = "Numero";
        System.out.println(datoObtenido+" -> "+contador);
        contador++;
        dummie++;
        dummieFinal = dummie / 10;
        try {
    wait();
      } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
        }
    }
    System.out.println("Hilo Detenido");
   
        }
       
    public static void main(String args[]) {
       thread = new threadChat("Prueba");
       thread.setPriority(10);
       thread.start();
       threadLectura.setPriority(9);
       int max = 10;

       while(true){
        try {
Thread.sleep(15);
} catch (InterruptedException e) {e.printStackTrace();
}
synchronized (thread) {
               
                    thread.notify();
                    if (thread.contador == max) {
                    try {
                        thread.setRun(false);
                        thread.sleep(1500);
                       int numeroDummie = 0;
                       numeroDummie++;
                        System.out.println("Secuencia numero " + thread.contador / 11 + " finalizada.");


                        max += 10;
                        System.out.println("Ya vamos por la secuencia " +  thread.dummieFinal);
                        thread.setRun(true);
                        if (thread.dummieFinal == 2) {
                            thread.setRun(false);
                            System.out.println("Secuencias finalizadas");
                           

                        }

                    } catch (InterruptedException ex) {
                        Logger.getLogger(threadChat.class.getName()).log(Level.SEVERE, null, ex);
                    }
                   
                   threadLectura.start();
                    }

               
   
       }
    }
    }
    public class ThreadRecojida extends Thread {
        public int datoRecepcionado;
    public ThreadRecojida(String str) {
        super(str);
    }
    public void run() {
        thread.setRun(false);
        datoRecepcionado = thread.dummieFinal;
        System.out.println("El dato recojido es: " + datoRecepcionado);

    }
}
}

Este codigo ejecuta un thread y luego otro thread se encarga de recojer el ultimo generado por la secuencia del primero, noe sta completo, la secuencia seguirá indefinidamente y cada 20 numeros, es decir cada dos secuencias el segundo thread se activa y recoje el ultimo valor de la secuencia ejecutada por el primero.

Saludos