Threadstart abfragen [ERLEDIGT]

[Manfred]

Hi,

ich hatte vor kurzem hier eine Frage, in der wir uns ausgiebig über Threads usw, unterhalten haben, leider finde ich diesen Beitrag nicht mehr. Deshalb mache ich jetzt einen neuen auf. Sorry.

Es geht darum, dass ich am Programmanfang alle Objekte erstelle und dann danach alle DB öffnen. Das dauert seine Zeit. Nun habe ich einen Thread davor geschaltet, der zumindest ein Fenster aufmacht, in dem steht, das was passiert. So weit so gut.

Jetzt steht da aber auch nur "mache dies und das, bitte warten" Also dachte ich mir, ich erstelle ein Static im Threadfenster und mache dann vor jedem Objekt ein setcaption("ich tue jetzt das") umd unten am Rand anzuzeigen, was so gerade läuft. (Hat mich immer schon fasziniert). Leider ist mir gerade bitterböse aufgefallen, das der Thread noch nicht richtig fertig ist, wenn das erste setcaption() erfolgen würde. Und somit gibt es eine Fehlermeldung, dass es das Staticobjekt noch nicht gibt.

Hm, wer kann mir denn mal wieder auf die Beine helfen, wie man sowas elegant lösen kann? Also irgendwie abwarten, bis der Thread läuft und dann erst weitermachen mit dem Programmablauf.

[brandelh]

Hi,

dazu dient die Signal Klasse ...
sieh mal das Kaffeemaschienen Beispiel an, dort wird per Signal() gesteuert,
dass immer nur einer Kaffee kocht und alle anderen darauf warten ...

du könntest natürlich auch einfach bei dem Anzeigethread abfragen ob der Status des static auf create steht ;
Wenn nicht, braucht man nix anzeigen, wenn ja ...

[Manfred]

Hi Hubert,

nur nochmal kurz damit wir von der gleichen Sache reden. Ich habe nämlich im Moment kein Wort verstanden:

Code: Alles auswählen

oThread := warten():new()
oThread:start(,,"Initialisierung der Parameter...")
oThread:oAblauf:setcaption("Anzahlungen")  <-- hier ist der Thread aber noch nicht erzeugt und deshalb knallt es....
oAnzahlungen            := bestellungen():new()

Der thread müßte erst erzeugt werden und dann müßte der zusätzliche Hinweis kommen.

[Jan]

manfred,

ich selber gehe da etwas anders ran (aber es funktioniert immer). Bei mir sind das 2 Funktionen. Die erste erzeugt den Therad, und die zweite macht das, was in diesem Thread passieren soll. Also z. B.:

Code: Alles auswählen

oThread := Thread():new()
oThread:start("DieFunktion", parameterliste)

Function DieFunktion(parameterliste)
...

// Irgendwo hier drin auch das oThread:quit()

...

Return nil

Jan

[brandelh]

Hallo Manfred,

ich habe noch nie gesehen, dass ein Threadobjekt selbst auch noch eine Anzeige hat ... ich will ja nicht sagen, dass es
nicht geht, aber ... ich mache es auch so wie JAN. Der Gui Thread ist für Anzeigen zuständig, der Laufthread muss nur die Infos an den anderen übergeben (also ein Parameter eines Dialoges / drawingarea oder XbpPart -> Thread/funktion füttert diesen, Anzeige außerhalb.

Ich habe (ohne Thread) schon länger eine eigene Funktion dafür ...

Code: Alles auswählen

*----------------------------------------------------------------------------------------
function WaitBox( cTitel,bAktion )          // Wartezustand anzeigen Frher ZeigWarten()
   local oXbp,aSize,uReturn, aPos

   default cTitel to "Wartezustand..."

   SetAppWindow():setPointer(,XBPSTATIC_SYSICON_WAIT,XBPWINDOW_POINTERTYPE_SYSPOINTER,.t.)
   SetAppWindow():drawingarea:setPointer(,XBPSTATIC_SYSICON_WAIT,XBPWINDOW_POINTERTYPE_SYSPOINTER,.t.)

*   aSize := AppDesktop():currentSize()                     // zentriert auf Desktop
   aSize := SetAppWindow():currentSize()                    // zentriert auf Anwendung
   oXbp := _ZeigWarten():New(,SetAppWindow())
   oXbp:title := cTitel
   oXbp:taskList := .F.
   oXbp:minButton:= .F.
   oXbp:SysMenu  := .F.
   oXbp:maxButton:= .F.
   oXbp:border   := XBPDLG_DLGBORDER
   oXbp:create()
   // zentriert auf Desktop - immer nur eines aktiv !
*   aPos := { (aSize[1]-oXbp:currentSize()[1])/2,;
*             (aSize[2]-oXbp:currentSize()[2])/2   }
   // zentriert auf Anwendung - immer nur eines aktiv !
   aPos := { SetAppWindow():currentPos()[1] + (aSize[1]-oXbp:currentSize()[1])/2,;
             SetAppWindow():currentPos()[2] + (aSize[2]-oXbp:currentSize()[2])/2   }

   oXbp:SetPos(aPos)

   oXbp:show()
   SetAppFocus(oXbp)

   If ! IsNIl(bAktion)
      uReturn := eval( bAktion )
   endif

   oXbp:destroy()
   SetAppWindow():drawingarea:setPointer(,XBPSTATIC_SYSICON_ARROW,XBPWINDOW_POINTERTYPE_SYSPOINTER)
   SetAppWindow():setPointer(,XBPSTATIC_SYSICON_ARROW,XBPWINDOW_POINTERTYPE_SYSPOINTER)

RETURN uReturn
*----------------------------------------------------------------------------------------
CLASS _ZeigWarten FROM XbpDialog
   EXPORTED:
      VAR editControls

      * Enthaltene Kontrollelemente
      VAR Static1
      VAR PB_Cancel

      METHOD init
      METHOD create
ENDCLASS

METHOD _ZeigWarten:init( oParent, oOwner, aPos, aSize, aPP, lVisible )

   DEFAULT oParent  TO AppDesktop(), ;
           aPos     TO {368,206}, ;
           aSize    TO {221,103}, ;
           lVisible TO .F. , ;
           aPP      TO {}

   AAdd ( aPP, { XBP_PP_BGCLR, XBPSYSCLR_DIALOGBACKGROUND } )
   AAdd ( aPP, { XBP_PP_COMPOUNDNAME, "8.Arial" } )
   ::XbpDialog:init( oParent, oOwner, aPos, aSize, aPP, lVisible )
   ::XbpDialog:drawingArea:ColorBG := XBPSYSCLR_DIALOGBACKGROUND

   ::editControls := {}

   ::Static1   := XbpStatic():new( ::drawingArea, , {4,48}, {203,18} )
   ::Static1:caption := "bitte warten ..."
   ::Static1:clipSiblings := .T.
   ::Static1:options := XBPSTATIC_TEXT_VCENTER+XBPSTATIC_TEXT_CENTER

   ::PB_Cancel := XbpPushButton():new( ::drawingArea, , {55,7}, {100,24} )
   ::PB_Cancel:caption := "abbrechen"
   ::PB_Cancel:clipSiblings := .T.
   ::PB_Cancel:activate := {|| NIL }

RETURN self

METHOD _ZeigWarten:create( oParent, oOwner, aPos, aSize, aPP, lVisible )

   ::XbpDialog:create( oParent, oOwner, aPos, aSize, aPP, lVisible )

   ::Static1:create()

   ::PB_Cancel:create()
   ::PB_Cancel:disable()
   ::setPointer(,XBPSTATIC_SYSICON_WAIT,XBPWINDOW_POINTERTYPE_SYSPOINTER,.t.)
   ::drawingarea:setPointer(,XBPSTATIC_SYSICON_WAIT,XBPWINDOW_POINTERTYPE_SYSPOINTER,.t.)
   ::Static1:setPointer(,XBPSTATIC_SYSICON_WAIT,XBPWINDOW_POINTERTYPE_SYSPOINTER,.t.)
RETURN self

Nun will ich z.B. drucken (ohne neuen Thread ...), die Funktion ist in einer Methode des Fensters abgelegt und wird per click gestartet ...

Code: Alles auswählen

::pbPrint:activate := {|| waitbox("drucken, bitte warten ...", {|| ::Drucken() )}

da die Methode ::Drucken das Fenster kennt, kann ich darin einfach z.B. SLEs setzen oder Einstellungen abfragen ... (z.B. Disablen)
Wichtig ist, dass diese Funktion einfach durchläuft, sobald ::Drucken() fertig ist, wird das Fenster beendet.
CANCEL geht übrigens noch nicht ... aber wollte ich in diesem Fenster was anzeigen, dann müsste ich nur z.B. das Fenster oder das Control selbst übergeben ...

Code: Alles auswählen

in der Classe z.B. einfügen:

::XbpSLE_Zustandsanzeige ...
...
   If ! IsNIl(bAktion)
      uReturn := eval( bAktion, ::XbpSLE_Zustandsanzeige )
   endif
... diesen Parameter als oSLE übergeben
::pbPrint:activate := {|| waitbox("drucken, bitte warten ...", {|oSLE| ::Drucken(oSLE) )}
... und in der Methode Drucken ....
oSLE:setData("mein Zustand")

du siehst, das geht alles auch ohne eigenen Thread ... aber wenn du in der aufgerufenen Funktion
einen Thread startest, der die eigentliche ausführende Funktion aufruft und alle nötigen Parameter durchreicht, dann geht das ...

ich fange mal eine neue Message an...

[Manfred]

OK,

ich mache den Thread als ERLEDIGT. Das wird mir schon wieder zu kompliziert im Moment. Ich wollte eigentlich nur eine einfache Lösung haben, aber sieht mir wieder nach einer Mammutaktion aus.

Danke trotzdem....

[brandelh]

in diesem Beispiel habe ich eine Seite auf der die Eingaben für die Arbeit im Thread erledigt wurden: oDLG
Auf dieser Seite wird per Button dann ein Import gestartet (ich schreibe das nun mal aus, damit es klarer wird):

Code: Alles auswählen

...
oDLG:pbImportStarten:activate := {|| ::DateiImportieren() } // Main/GUI-Thread
oDLG:oThread                         := NIL
...
method ... oDLG:DateiImportieren()                                   // Main/GUI-Thread
   ... alle Variablen aus GUI holen und übergeben z.B. Dateiname etc.
   oDLG:pbImportStarten:disablen()   // kein doppelter Aufruf
   ...
   ::oThread := Thread():new()
   ::oThread:start("DoDateiImport",oDLG,cDatei)  // übergebe das Fenster für Anzeigen und Dateiname an Arbeitsfunktion.
                          // -> dies gibt der neue Thread ... die Funktion steht aber ganz normal im Quellcode
   // nach Ende des Threads wird dieser die Controls wieder enablen()
...
return self

function DoDateiImport(oDLG,cDatei)      // diese Funktion läuft im neuen Workerthread
    ... mach was und rede drüber            // wenn Sie über oThread:start() aufgerufen wird.
    oDLG:oSleInfoFeld:setData("Hol dir noch einen Kaffee ...") // Dieser Text wird immer im GUI Thread angezeigt.
    ... Aufräumen
    oDLG:pbImportStarten:enablen()   // kein doppelter Aufruf
return nil

Die Funktion DoDateiImport(oDLG,cDatei) arbeitet auch bei direktem Aufruf ohne neuem Thread
genau gleich !
Die WaitBox() Funktion macht normalerweise Aktionen, die den Rechner blockieren sollen:
- neue Indexdateien aufbauen
- Datensatz drucken
- Liste drucken
...
hier möchte ich nicht, dass verschiedene Thread in meiner Anwendung herumspuken ...
Die DoDateiImport() Funktion muss aber 400 MB Textdateien durchlaufen und Daten importieren.
Da war vor dem Thread immer die GUI tot (was nicht disabled war), nun ist nur disabled was
so sein soll und der Rest reagiert (auch wenn nicht viel erlaubt ist während des Imports )

...

Ejjje was soll das nachdem ich so viel geschrieben habe ...

[brandelh]

OK,
ich mache den Thread als ERLEDIGT. Das wird mir schon wieder zu kompliziert im Moment.
Ich wollte eigentlich nur eine einfache Lösung haben, aber sieht mir wieder nach einer Mammutaktion aus.
Danke trotzdem....

Eine einfache Antwort ...

TRENNE die Arbeit (im Thread) von der Anzeige !

alles was dein Thread an die Funktion weitergeben muss, ist eine Referenz auf das Anzeige-Fenster.

[Manfred]

OK,

das ist mal ein anderes Wort. Ich denke jetzt komme ich wieder ein bisschen mit.

Vielleicht habe ich mich auch nicht richtig ausgedrückt am Anfang.

Der Thread gibt nichts an eine Funktion weiter, oder so. ch habe nur eine Möglichkeit gesucht, die mir ein Fenster aufmacht in dem steht: "Bitte warten...."
Da aber der Rest im "Hintergrund" weiterlaufen soll, wurde eben ein Thread gewählt. Hier nochmal der Weg.

Code: Alles auswählen

oThread := warten():new()
oThread:start(,,"Initialisierung der Parameter...")

oAlgPara               := parameterallgemein():new()
oAnkauf                := ankauf():new()
oAnkauf2               := ankauf():new()                              // dient der Statistikermittlung                               .
oAnkaufDaten           := ankaufdaten():new()                         // hier sind die Ankaufdaten drin, die noch im Ankauf stehen   .
oAnkaufDatenVo         := ankaufdaten():new()
oThread:terminate()

mehr ist da nicht

der Thread sieht so aus

Code: Alles auswählen

CLASS warten FROM THREAD
      PROTECTED:
      VAR oDialog,;                                                             // Fenster für den Thread allgemein
          oStatic                                                               // Hinweis, was gemacht wird
      VAR terminated

      EXPORTED:
      VAR oAblauf                                                               // Hinweis, was womit gerade gemacht
// sollte das evtl. in eine ACCESS Methode gepackt werden? (27.08.2009)
      INLINE METHOD INIT
             ::thread:INIT()
             ::terminated := .F.
      RETURN self

      INLINE METHOD terminate
      RETURN( ::terminated := .T. )

      METHOD checkTerminated
      METHOD execute
ENDCLASS
********************************************************************************
METHOD warten:execute(para1,cText)
       LOCAL aPP     := {;
                         {XBP_PP_COMPOUNDNAME,"16.Times New Roman"};
                        }

       DEFAULT para1 TO ""
       DEFAULT cText TO "Bitte warten..."

       ::oDialog          := DialogFenster():new(,,,{400,240} )
       ::oDialog:create()
       ::oStatic          := feldtexte():new(::oDialog:drawingarea,,,,aPP)
       ::oStatic:autosize := .T.
       ::oStatic:caption  := cText
       ::oStatic:create()
       ::oAblauf          := feldtexte():new(::oDialog:drawingArea)
       ::oAblauf:autosize := .T.
       ::oAblauf:caption  := ""
       ::oAblauf:options  := XBPSTATIC_TEXT_LEFT
       ::oAblauf:create()
       ::oAblauf:setsize({::oDialog:clientSize[1],20})
       CenterControl(::oDialog)
       CenterControl(::oStatic)
       DO WHILE ! ::terminated
          Sleep(.1)
          ::checkTerminated(::oDialog)
       ENDDO
RETURN self
********************************************************************************
METHOD warten:checkTerminated()
       IF ::terminated
          ::terminated := .F.
          ::oDialog:destroy()
          ::quit()
       ENDIF
RETURN self

Genügt das fürs erste?

[Martin Altmann]

Manfred,
falsch rum! Denke mal an unsere andere Diskussion zu dem Thema (die Du oben bereits angesprochen hast):
Du mußt in Deiner Hauptanwendung das Anzeigefenster aufmachen und den Static, der die Hinweise darstellen soll, als Parameter bei dem Starten der Threads mitgeben!
In den Threads musst Du dann mittels Parameter:SetCaption("Text") die Hinweise setzen!

Viele Grüße,
Martin

[Manfred]

Haha,

jetzt verstehe ich euer Problem.

Das System klappt ja, aber erst nachdem der Thread gestart ist. Da der aber asyncron vom Rest gestartet wird, hinkt der hinterher.
Wenn ich setcaption() irgendwann später mache, dann klappt es. Meine Frage war jetzt nur, wie ich das schaffen könnte das setcaption erst zu machen, wenn der Thread schon läuft. Weil direkt nach dem Start vom Thread, ist mindestens die 1.Instanzbildung schon dabei sich zu bauen. Da steht der Thread aber noch nicht. Der steht erst ab der 3. oder 4. Instanz. Je nachdem, wie das OS die Zeitschiene vergibt. Bis dahin knallt es halt, wenn ich setcaption mache. Also bringt eine Übergabe an den thread auch nichts, weil der entweder noch nicht steht, oder aber die nachfolgenden Instanzen schon ganz woanders sind, bis er steht.

So, prima ausgedrückt. Jetzt warte ich mal was draus wird.

[Martin Altmann]

Lötzinn!
Du machst Dein Anzeigefenster - und die Threads starten ja erst, wenn das Fenster angezeigt wird - und dann ist selbstverfreilich ein Zugriff aus dem Thread auf das Static möglich!

Viele Grüße,
Martin

[Manfred]

Moment

bin ich schwer von Dussel, oder wie?

Welche Threads? Der eine Thread erzeugt das Fenster "bitte warten". Mehr Threads gibt es nicht. Aber bevor der Thread erzeugt wurde, wird das nachfolgende Programm abgearbeitet. Wenn ich den Thread im Debugger ablaufen lasse und dort stoppe, dann läuft der Rest trotzdem weiter. Egal, ob das Fenster nun angezeigt wird oder nicht. Das was im Text danach steht ist meine Proc main() und kein getrennter Thread. Theoretisch würde es auch genügen, wenn ich einen Dialog erzeuge, der nur anzeigt und dann später wieder destroyed wird, damit er vom Bildschirm verschwindet. Warum wir damals auf den Thread gekommen sind, weiß ich auch nicht mehr. Ich denke mal, ich werde mir das mit dem einfachen Dialogfenster nochmals überlegen, weil es mir jetzt wesentlich günstiger erscheint es so zu regeln. Aber irgendeinen Grund für den Thread muß es damals gegeben haben.

[brandelh]

Hallo Manfred,

wenn du NUR eine Anzeige während einer Hintergrundaktion willst, dann nimm meinen WaitBox() Code von oben !
Der braucht weder Threads noch sonst was !

Dort kannst du auch noch ein Static einfügen und dieses Fenster ist auf jeden Fall da, bevor die Arbeitsfunktion startet.

[Manfred]

Hi Hubert,

ich werde mir das mal anschauen. Ich bin nur vorhin von der Menge erschlagen worden und habe dann etwas zurückgerudert. Aber GUI ist nun mal mehr Text als VIO.

[AUGE_OHR]

hi,

ich habe eine "Fieldwide" STATIC IsRunning

Code: Alles auswählen

STATIC isRunning := .F.

PROCEDURE BlaBla

IF isRunning
ELSE
   oThread := Thread():new()
   oThread:start("DieFunktion", parameterliste)
   SLEEP(100*3) // Zeit lassen um den Thread zu starten
   DO WHILE isRunning
        SLEEP(0)
   ENDDO
ENDDO
RETURN

Function DieFunktion(parameterliste)
...
   isRunning := .T.

   mache_was_du_willst()
...
   isRunning := .F.
Return nil