Ausführen von Methoden nacheinander und nacheinander

Question

Ich möchte eine Reihe von Methoden innerhalb einer Schaltfläche ausführen, aber einige benötigen weniger Zeit und einige benötigen mehr Zeit für die Verarbeitung und ich möchte, dass sie in einer bestimmten Reihenfolge als eine ausgeführt werden Methode funktioniert auf einem anderen Methoden output.My Ausführungstaste ist wie folgt: -

{ 
Basic b = new Basic(); 
b.method1(); //Normal processing 
b.method2(); //Normal processing 
b.method3(); //Heavy processing takes a lot of time like 5 to 10sec 
b.method4(); //Basic processing 
b.method5(); //Medium Processing FileHandling(works on 5 file) 
} 

Also, was passiert ist, dass alles geht perfekt und als Aufwärts bis zur Ausführung von method2 ausgenommen, sondern als kommt die method3 alles vermasselt wird. Also was passiert, ist, dass meine Methode3 übersprungen wird und Methode4 und Methode5 ausgeführt werden. Ich habe eine Null-Zeiger-Ausnahme erhalten, da sie von den Daten abhängt, die von der Ausführung von Methode3 empfangen werden.

Kann mir jemand sagen, wie ich sicherstellen kann, dass meine Methoden 4 und 5 erst ausgeführt werden, nachdem meine Methode3 abgeschlossen ist, und meine Methode3 enthält zwei Methoden aus der ersten Klasse, die einige Skripts erstellt und eine andere, die das ausführt Echtzeit, da es Bash-Shell verwendet.

P.S.-wie meine Schaltfläche ausgeführt wird, sehe ich, dass meine Methode3 nichts getan hat, als wäre es übersprungen worden oder so.

Code: -

public void method3(String abstarpath,String filename,String parapth) 
{ 
    try{ 
    String cmd1 = "tar xzf "+abstarpath; 
    String cmd2 = "mv "+ parapth+"/"+filename +" /home/apoorv/Desktop/"; 
    txtarea.append("#"+cmd1+"\n"); 
    txtarea.append("#"+cmd2+"\n"); 
    executeCommands(cmd1, cmd2);    
    }catch(Exception e){ 
     txtarea.append("#"+e+"\n"); 
     e.printStackTrace(); 
    } 
    txtarea.append("\n"); 
} 

public void executeCommands(String cmd1,String cmd2) throws IOException { 

    File tempScript = createTempScript(cmd1,cmd2); 

    try { 
     ProcessBuilder pb = new ProcessBuilder("bash", tempScript.toString()); 
     pb.inheritIO(); 
     Process process = pb.start(); 
     process.waitFor(); 
    } catch (InterruptedException e) { 
     txtarea.append("#"+e+"\n"); 
     e.printStackTrace(); 
    } finally { 
     tempScript.delete(); 
    } 
} 

public File createTempScript(String cmd1,String cmd2) throws IOException { 
    File tempScript = File.createTempFile("script", null); 

    Writer streamWriter = new OutputStreamWriter(new FileOutputStream(
      tempScript)); 
    PrintWriter printWriter = new PrintWriter(streamWriter); 

    printWriter.println("#!/bin/bash"); 
    printWriter.println(cmd1); 
    printWriter.println(cmd2); 
    printWriter.close(); 

    return tempScript; 
} 

Answer 1

an Ihrem Code Sehen, das Problem, das Sie haben scheint nichts mit Nebenläufigkeit zu tun zu haben. Das Problem ist, dass Ihre Hauptmethode nicht weiß, ob die methodX() Methoden erfolgreich beendet wurden.

Was können Sie tun, ist die Ausnahmebehandlung zu Ihrem Hauptverfahren verschieben:

try { 
    Basic b = new Basic();  
    b.method1(); //Normal processing 
    b.method2(); //Normal processing 
    b.method3(); //Heavy processing takes a lot of time like 5 to 10sec 
    b.method4(); //Basic processing 
    b.method5(); //Medium Processing FileHandling(works on 5 file) 
} 
catch (Exception e) { 
    // error handling 
} 

(Und natürlich müssen Sie die Ausnahme entfernen von Ihren anderen Methoden arbeiten).

Sobald eine der Methoden eine Ausnahme auslöst, wird der Rest der Methoden übersprungen und der Ausnahmebehandler ausgeführt.

Answer 2

Sie Dies wird

static void Main(string[] args) 
    { 

     SynchronizationContext.SetSynchronizationContext(new SynchronizationContext()); 

     Task.Factory.StartNew(() => 
     { 
      return Method1(); 
     }).ContinueWith((t) => { 
      return Method2(t.Result.ToString()); 

     }).ContinueWith((p) => 
     { 
      return Method3(p.Result.ToString()); 
     }, TaskScheduler.FromCurrentSynchronizationContext()); 

     Console.ReadLine();   
    } 

    public static string Method1() 
    { 
     for(int i =0;i<20;i++) 
     { 
      Thread.Sleep(400); 
      Console.WriteLine("Working in Method1"); 
     } 
     return "return from method1"; 

    } 
    public static string Method2(string input) 
    { 
     for (int i = 0; i < 30; i++) 
     { 
      Thread.Sleep(600); 
      Console.WriteLine(input + " to Method 2"); 
     } 
     return "Input from Method2"; 
    } 
    public static string Method3(string input) 
    { 
     for (int i = 0; i < 50; i++) 
     { 
      Thread.Sleep(300); 
      Console.WriteLine(input + " to Method 3"); 
     } 
     return "Input from Method3"; 
    } 
}