ThreadPoolExecutor

[Osix2000]

Ähnlihce Frage:

Kann ich einzelne Threads, die im ThreadPoolExecutor übergeben sind, oder von diesem Verwaltet werden auch

"händisch" stoppen, warten lassen und wieder anlaufen lassen ?

int g = 0;
                
                // Anzahl aller anstehenden Threads
                int anzahl = 20;
               
                // Größe des Threadpools, d.h. vorhandene gleichzeitige Ausführungsplätze
                int tpSize = 5;
                
                ThreadPoolExecutor tp = new ThreadPoolExecutor(tpSize,tpSize,50000L,TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());

Soweit ist es klar, mein TPE ist definiert.
Jetzt laß ich ihn loslaufen und lege Aufgaben auf die Plätze

 for (int i = 1; i < anzahl; i++)
                    {
                        //int random = (int) (Math.random()*1000)+1;                        
                        
                        Random r1 = new Random();
                        
                        int r2 = (int)(r1.nextDouble()*1000);
                        
                        String r3 = String.valueOf(r2);
                        
                        g = g + r2;
                        
                        task[i] = new OutputController(PROGRAM_PATH + "rechnung.bat", "Task-ID:" +i, r3);
                        tp.execute(task[i]);
                    }

(Die Task sinds grade DOS-Batch Programme, die einen Tasknamen bekommen, und über die Variable r3 eine zufällige Wartezeit.

task[0] = new OutputController(PROGRAM_PATH + "rechnung.bat", "Task-ID:0" , "8000");
                tp.execute(task[0]);

Dies mache ich um absichtlich den Task0 händisch mit einer extra langen Laufzeit zu belegen.

(Der Outputcontroller übernimmt als eigene Klasse, die Ausführung mithilfe des Processbuilders)

Meine Frage: Ich würde jetzt gerne mal "händisch" den Task[0] wieder anhalten...
Oder auch andere Tasks... Und dann "händisch" wieder starten.

Und dazu finde ich einfach nichts. Es müßte doch so gehen: tp.wait(task[0]) aber das geht nicht..

Später brauche ich das auch, da werden .exe Dateien ausgeführt über eine Workflow-Engine... und die müssen
auch angehalten werden können.

Geht das überhaupt mit dem ThreadPoolExecutor ? Oder muß ich da ExecutorService verwenden ?

 

[jPat]

Meiner Meinung nach kann man Threads nicht einfach stoppen, nur mit .sleep anhalten, bzw schlafen legen. du kannst aber deine Threads eine Methode schreiben, die das kann.

class Mythread extends Thread {
 private running = true;

 public void run(){
  while(running){
    //tue irgenwas
  }
 }
 public stopThread(){
  running = false;
 }
}

diese Methode kann auch erweitert werden durch:

public void run(){


while (running){
   while (sleep) Thread.sleep(1000)
// tue irgendwas ...




}


}

 

[osix2000]

ich glaub Du verwechselst was.

Klar, was Du beschreibst gilt für "einfache" Threads...

Ich verwende aber die Concurrency API ab JDK 1.5 und da muß man sich ja um die Dinge an sich nicht mehr selber kümmern.

Man erzeugt einen Threadpool und legt die runnable Task auf die Threadpool-Plätze....

ExecutorService tp = Executors.newCachedThreadPool();
tp.submit(task[i]);

Mir ist nur noch nicht ganz klar, wie ich "händisch" auf einzelne Tasks, die da laufen, (also z.B. task[5]) zugreifen kann.
Weil manchmal muß man ja von außen, hart einen Thread beenden können, oder in Wartestellung schicken und wieder aufwecken will.