Hi,

ich habe grad folgendes Problem:

Also es wird im Hauptthread eine Procedure ausgeführt innerhalb dieser Procedure wird eine Aktion in einem Thread angestoßen:

(pseudo-code)

markieren

Delphi-Quellcode:

procedure Exec(Befehl: string);
begin

Plink.MacheBefehl(Befehl); //Läuft in nem Thread ab

Sleep(5000); //Das soll dem Thread die Zeit geben sein Ding zu erledigen.

Ergebnis := PlinkUnit.Befehlrückgabe; //TStringList
end;

So was jetzt passiert ist, dass im "Ergebnis" alles landet was VOR dem Befehl bereits darin stand - der neu ausgeführte Befehl wird nicht übernommen bzw. dessen Rückgabe.

In einer 2. Procedure:

markieren

Delphi-Quellcode:

procedure ShowMe;
begin
Ergebnis := PlinkUnit.Befehlrückgabe;
end;

die nach der oberen ausgeführt wird (per Button) steht der Befehl dann aber plötzlich drin!

Also ich habe jetzt folgende zwei Vermutungen:

1. Möglichkeit:
- Exec wird ausgeführt
- Variable "Befehlrückgabe" wird gecached (warum auch immer)
- Code der Procedure Exec wird ausgeführt
-- innerhalb der Procedure wird dann die vorher zwischengespeicherte Variable ausgelesen und vorher war der Befehl noch nicht drin..

2. Möglichkeit:
- Exec wird ausgeführt
- Code der Procedure Exec wird ausgeführt (Befehlrückgabe geschrieben)
- Erst danach wird die betreffende Funktion ausgeführt die überhaupt die Rückgabe von Plink ausliest
- Befehlrückgabe wird neu gesetzt


So die Frage an euch.. woran kann das normalerweise liegen. Ich glaube nicht, dass eine Variable für die Procedure zwischengespeichert wird oder?

lg

Versuchs mal mit WaitForSingleObject und warte bis der Thread fertig ist. Eventuell reichen die 5Sekunden nicht aus um die Arbeit zu verrichten. Oder hab ich da was missverstanden?

Ne die reichen aus sind sogar viel zu lang kalkuliert.. es erscheint einfach nichts "neues" in der Ergebnis-Var (in dem Fall ein Memo).

Es wird wirklich jedesmal nur das reingeschrieben was davor auch schon drin stand aber nach Ablauf der Procedure lässt sich das direkt auslesen :/

Wenn ich mir die PLinkRemote.pas anschaue dann wird alles in einem Thread ausgeführt (ganz unten ist das deklariert) deshalb müsste das eigentlich auch nach der Sleep-Zeit auslesbar sein.

Guten Abend,

mir sei einmal eine etwas ketzerische Frage erlaubt.
Warum wird hier ein Thread benutzt, wenn dann doch wieder auf das
Ergebnis gewartet werden soll.

markieren

Delphi-Quellcode:

procedure Exec(Befehl: string);
begin

Plink.MacheBefehl(Befehl); //Läuft in nem Thread ab

Sleep(5000); //Das soll dem Thread die Zeit geben sein Ding zu erledigen.

Ergebnis := PlinkUnit.Befehlrückgabe; //TStringList
end;

Mir erschließt sich der Sinn nicht so richtig.

Grüße
Klaus

Plink muss wohl kontinuierlich befürsorgt werden damit es nicht den Geist aufgibt ^.^ keine Ahnung die Lib hab ich nicht geschrieben und so wirklich 100% verstehen tu ich das Ding auch nicht ich weis nur das alles was ich im PuTTY sehen würde auch in dieser Variable landet und deshalb Execute->Wait->Process um das zu verarbeiten - ich wüsste nicht wie das anders gehen soll außer in nem Timer aber das finde ich dann eher Patch-Work-Programmiert

Also ich hab mir die Lib. selbst noch einmal angeguckt und durch ne Änderung daran geht's jetz..

zusammenfalten · markieren

Delphi-Quellcode:

procedure TReadpipeThread.Execute;
 var CS_Readdata :TCriticalSection;
begin
  inherited;
  CS_Readdata := TCriticalSection.Create;
      while (WaitForSingleObject(m_pi.hProcess, 1) <> Wait_Object_0) do
      begin
           Synchronize(m_Client.Read_error);
           Synchronize(m_Client.read_output);
          if terminated then break;
      end;
  CS_Readdata.Free;
end;

Das ist die ursprüngliche Dingens wo der Output von PLink abgefragt wird. Das geschieht in der Funktion m_Client.read_output
Was ich jetzt geändert habe ist dieses Synchronize:

zusammenfalten · markieren

Delphi-Quellcode:

procedure TReadpipeThread.Execute;
 var CS_Readdata :TCriticalSection;
begin
  inherited;
  CS_Readdata := TCriticalSection.Create;
      while (WaitForSingleObject(m_pi.hProcess, 1) <> Wait_Object_0) do
      begin
           m_Client.Read_error; //<---
           m_Client.read_output;//<---
          if terminated then break;
      end;
  CS_Readdata.Free;
end;

Kann mir jemand erklären was ich damit verändert hab' und ob sich das evtl. negativ auswirken kann im späteren Verlauf?

Synchronize lässt die übergebenen Funktionen im Kontext des Mainthreads ausführen.

Das erklärt natürlich alles