🚀 go-pugleaf

"Lothar" <Lothar.Huppertz@gmx.de> wrote in message
news:4087889d@newsgroups.borland.com...

> and how do I reexecute a thread which was used before?

By not allowing the thread to terminate in the first place, until you are
actually done using it completely.  Once the thread finishes what it is
doing, you can reuse it by simply suspending the thread when its operation
is done, and making sure Execute()'s main code can run multiple times.  Then
just store your thread instances into a list while they are running.  When
your application code needs to start a thread for an operation, go to the
list first to see if any suspended threads are waiting.  If so, just reset
the thread's variables and inner resources as needed and then Resume() the
thread.  If there are no threads waiting, then create a new thread instance
fresh.  For example (untested):

    class LockListHelper
    {
    private:
        TThreadList *FThreadList;
        TList *FList;
    public:
        LockListHelper(TThreadList *AList) : FThreadList(AList), FList(NULL)
        {
            if( FThreadList )
                FList = FThreadList->LockList();
        }
        ~LockListHelper()
        {
            Unlock();
        }
        Unlock()
        {
            if( FThreadList )
            {
                FThreadList->UnlockList();
                FThreadList = NULL;
                FList = NULL;
            }
        }
        operator bool () const {return (FList != NULL); }
        TList* operator ->() {return FList; }
    };


    TThreadList *Threads = NULL;

    __fastcall TForm1::TForm1(TComponent *Owner)
        : TForm(Owner)
    {
        Threads = new TThreadList;
    }

    __fastcall TForm1::~TForm1()
    {
        LockListHelper List(Threads);
        if( List )
        {
            for(int x = 0; x < List->Count; ++x)
            {
                TMyThread *Thread = (TMyThread*)(List->Items[x]);
                Thread->Terminate();
                Thread->Resume();
            }
            List.Unlock()

            while( LockListHelper(Threads)->Count > 0 )
                Sleep(100);
        }

        delete Threads;
        Threads = NULL;
    }

    void __fastcall TForm1::Button1Click(TObject *Sender)
    {
        TMyThread *Thread = NULL;

        LockListHelper List(Threads);
        if( List )
        {
            for(int x = 0; List->Count; ++x)
            {
                TMyThread *Temp = (TMyThread*)(List->Items[x]);
                if( (Temp->Suspended) && (!Temp->Terminated) )
                {
                    Thread = Temp;
                    break;
                }
            }
        }

        if( Thread == NULL )
            Thread = new TMyThread(Threads);

        Thread->Resume();
    }


    class TMyThread : public TThread
    {
    private:
        TThreadList *FList;
        void __Fastcall MyExecute();
    protected:
        void __fastcall Execute();
        void __fastcall DoTerminate();
    public:
        __fastcall TMyThread(TThreadList *AList);
        __property Terminated;
    };

    __fastcall TMyThread::TMyThread(TThreadList *AList)
        : TThread(true), FList(AList);
    {
        FreeOnTerminate = true;
        if( FList )
            FList->Add(this);
    }

    void __fastcall TMyThread::Execute()
    {
        while( !Terminated )
        {
            // reset any variables and resources here as needed...

            MyExecute();

            // perform any needed cleanup here...

            if( !Terminated )
                Suspend();
        }
    }

    void __fastcall TMyThread::MyExecute()
    {
        // your usual Execute() code goes here...
        // don't call Terminate() unless you really mean it!
    }

    void __fastcall TMyThread::DoTerminate()
    {
        try {
            TThread::DoTerminate();
        }
        __finally {
            if( FList )
                FList->Remove(this);
        }
    }

I'm sure there's more to it than that, but that is the basics to get you
started.


Gambit