仅在先前线程返回后才开始新的wxThread

Question

CASE 1: I am using wxThreads , I am creating threads using 2 for loops. I have a MyThreads class which is inherited from wxThread class. Also, every thread creates a wxThreadEvent before exit and sends data to main program. Main program executes DoThisWorkAfterThreadReturns() after every thread is finished. what I want to do is, all threads with level=0 can execute simultaneously. But before creating threads with level = 1 , all level 0 threads should have finished their execution and DoThisWorkAfterThreadReturns() execution for all level 0 threads should also be finished. How should I do this using wxWidgets ?

for(level=0;level<n;level++)
{
     for(int i=0;i<no;i++)
     {
          //threads in this loop can execute simultaneously.
          MyThread *thread = new MyThread(this);
          thread->create();
          thread->run();
     }
     //wait till all threads for given level finish execution and execute 
      DoThisWorkAfterThreadReturns()
}

CASE 2: If CASE 1 is not possible then can I do following ?

  for(i=0;i<n;i++)
  {
       MyThread *thread = new MyThread(this);
       thread->create();
       thread->run();
       // wait till this thread finishes its execution, returns data to main program and main program finishes execution of DoThisWorkAfterThreadReturns()
      // after this only execute i++(i.e. next thread)
  }

can I wait for every thread to finish before creating a new thread from for loop ? It is necessary to create threads as I am sending backend requests which takes a long time sometimes.

Answer 1

I don't think this can be done simply. Here's one example of a way to do it. I'm using a simple application with a text control and a button. To accomplish what you have described above, I've split the work between 3 functions.

The first function starts the work of the outer loop. In this example, it's an event handler for the button.

The second function spawns a number of threads and basically corresponds to the inner loop described above. The threads in this example are dumb. They simply wait for a random amount of time between 0 and 5 seconds, throw an event to announce they are done, and then delete themselves.

The third function is a thread event handler called when each thread is finished. It basically finishes the work of the outer loop. It checks the number of threads running, and if that is zero it will either start a new iteration of the inner loop or finish.

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

// for all others, include the necessary headers (this file is usually all you
// need because it includes almost all "standard" wxWidgets headers)
#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include <wx/thread.h>
#include <stdlib.h>     /* srand, rand */
#include <time.h>       /* time */

class MyThread : public wxThread
{
    public:
        MyThread(wxEvtHandler *handler,int sleeptime)
            : wxThread(wxTHREAD_DETACHED)
            { m_pHandler = handler;m_sleepTime= sleeptime;}
    protected:
        virtual ExitCode Entry();

        wxEvtHandler *m_pHandler;
        int m_sleepTime;
};

wxThread::ExitCode MyThread::Entry()
{
    // A real application would do something here,
    // but for this example the only thing done is sleeping
    Sleep(m_sleepTime);

    // The work is done.  Throw a thread event to announce this to the frame.
    wxThreadEvent* exitEvent = new  wxThreadEvent();
    exitEvent->SetInt(m_sleepTime);
    wxQueueEvent(m_pHandler, exitEvent);
    return (wxThread::ExitCode)0;
}

class MyFrame : public wxFrame
{
    public:
        MyFrame( wxWindow* parent, int id = wxID_ANY, wxString title = "Demo",
                 wxPoint pos = wxDefaultPosition, wxSize size = wxSize(481,466),
                 int style = wxDEFAULT_FRAME_STYLE|wxTAB_TRAVERSAL );
    private:
        void OnButton(wxCommandEvent& event);
        void OnThreadComplete(wxThreadEvent& event);
        void SpawnThreads();

        int m_outerLoopCounter;
        int m_outerLoopLimit;
        int m_threadsToUse;

        wxCriticalSection m_threadsRunningCS;
        int m_threadsRunning;

        wxTextCtrl* m_textCtrl;
        wxButton* m_button;
};

MyFrame::MyFrame( wxWindow* parent, int id, wxString title, wxPoint pos
                 , wxSize size, int style )
        :wxFrame( parent, id, title, pos, size, style )
{
    wxPanel* panel = new wxPanel(this);
    wxBoxSizer* szr = new wxBoxSizer( wxVERTICAL );

    m_textCtrl = new wxTextCtrl( panel, wxID_ANY, wxEmptyString,
                                 wxDefaultPosition, wxDefaultSize,
                                 wxTE_DONTWRAP|wxTE_MULTILINE );
    szr->Add( m_textCtrl, 1, wxALL|wxEXPAND, 5 );

    m_button = new wxButton( panel, wxID_ANY, "Spawn");
    szr->Add( m_button, 0, wxALL, 5 );

    panel->SetSizer( szr );
    Layout();

    srand(time(NULL));
    m_outerLoopLimit = 3;
    m_threadsToUse = 4;

    Bind( wxEVT_THREAD, &MyFrame::OnThreadComplete, this);
    m_button->Bind( wxEVT_BUTTON, &MyFrame::OnButton, this );
}

void MyFrame::OnButton(wxCommandEvent& event)
{
    m_button->Disable();
    m_outerLoopCounter=0;
    SpawnThreads();
}

void MyFrame::SpawnThreads()
{
    (*m_textCtrl) << "spawning threads for loop " << m_outerLoopCounter+1;
    (*m_textCtrl) << " of " << m_outerLoopLimit <<"\n";

    m_threadsRunning=0;
    for ( int i=0; i<m_threadsToUse; ++i )
    {
        int sleeptime = rand()%5000;
        (*m_textCtrl) << "\tthread " << i << " will sleep for ";
        (*m_textCtrl) << sleeptime << " ms.\n";
        MyThread* thread = new MyThread(this,sleeptime);

        wxCriticalSectionLocker enter(m_threadsRunningCS);
        ++m_threadsRunning;

        if ( thread->Run() != wxTHREAD_NO_ERROR )
        {
            wxLogError("Can't create the thread!");
            delete thread;
            --m_threadsRunning;
        }
    }
}

void MyFrame::OnThreadComplete(wxThreadEvent& event)
{
    (*m_textCtrl) << "\tThe thread that slept for ";
    (*m_textCtrl) << event.GetInt() << " ms has finished.\n";

    // Check the number of threads that are still running
    bool canStop = false;
    {
        wxCriticalSectionLocker enter(m_threadsRunningCS);
        --m_threadsRunning;
        if ( m_threadsRunning == 0 )
        {
            canStop=true;
        }
    }

    // If there are zero threads still running, either enter a new iteration
    // of the outer loop or stop if the outer loop is complete.
    if(canStop)
    {
        ++m_outerLoopCounter;
        if ( m_outerLoopCounter<m_outerLoopLimit )
        {
            SpawnThreads();
        }
        else
        {
            (*m_textCtrl) << "All Done.\n";
            m_button->Enable();
        }
    }
}

class MyApp : public wxApp
{
    public:
        virtual bool OnInit()
        {
            MyFrame* frame = new MyFrame(NULL);
            frame->Show();
            return true;
        }
};

wxIMPLEMENT_APP(MyApp);

There are some downsides here. The outer loop counter and the number of threads running need to be tracked with variables available in multiple functions. So they need to be either global variables or members of the frame or app class. Also, I think the variable for the number of running threads should be guarded with a critical section. (I could be wrong, but in the example above, I decided to be safe and used the critical section.)

There may be a simpler way to do this. It's just the first thing I've tried.

Answer 2

wxSemaphore is a counter. wxSemaphore::Wait() waits if the internal counter is zero, otherwise it decrements the counter and returns.

You need the opposite to wxSemaphore , something that waits until the counter is zero.
Set a var (let's call it tVar ) that increments when the thread starts and decrements when the thread ends.

class MyThread : public wxThread
{
    ....
    MyThread(someObject *obj, wxEvtHandler *evtH) //someObject is where tVar lives, evtH is where we will post an event
    { m_obj = obj;  m_evtH = evtH;}
    ....
    someObject *m_obj;
    wxEvtHandler *m_evtH;
};

wxThread::ExitCode MyThread::Entry()
{
    //Increment the var
    wxCriticalSection locker(m_obj->someCritSec) //someCritSec must be accessible in someObject
    locker.Enter();
    m_obj->IncrementVar();
    locker.Leave() //Allow other threads to increment the var while this thread is still working

   //do the task
   .....

   //and decrement through a message
    wxQueueEvent(m_evtH, new wxThreadEvent(wxEVT_COMMAND_MYTHREAD_COMPLETED));

    return 0;
}

Class someObject is derived from wxEvtHandler (for example, a wxWindow) so it can receive the message. By an event-table or better by Bind() you have a handler for the thread completion event:

void someObject::OnThreadCompleted(wxThreadEvent&)
{
    //decrement the var
    --tVar;
    //Do something when it reaches 0
    if ( tVar == 0 )
        DoThisWorkAfterThreadReturns();
}

This solution allows the GUI to be responsive while threads are working.

Really no body is waiting. It's that DoThisWorkAfterThreadReturns is only executed when all threads have finished. The logic on which "levels" must "wait" or not is your decision.

There is a small caveat in this solution: if the first created thread finishes before another thread begins running the message will be posted and there's a chance that its handler is called before another thread increments the var.
You can avoid it by having tVar = 1 before any thread is created, and decrementing it (post an event) right after the last thread is created.