samples/thread/thread.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        thread.cpp
   3 // Purpose:     wxWidgets thread sample
   4 // Author:      Guilhem Lavaux, Vadim Zeitlin
   5 // Modified by:
   6 // Created:     06/16/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998-2009 wxWidgets team
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx/wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/wx.h"
  29 #endif
  30
  31 #if !wxUSE_THREADS
  32     #error "This sample requires thread support!"
  33 #endif // wxUSE_THREADS
  34
  35 #include "wx/thread.h"
  36 #include "wx/dynarray.h"
  37 #include "wx/numdlg.h"
  38 #include "wx/progdlg.h"
  39
  40 // ----------------------------------------------------------------------------
  41 // resources
  42 // ----------------------------------------------------------------------------
  43
  44 #include "../sample.xpm"
  45
  46 // ----------------------------------------------------------------------------
  47 // private classes
  48 // ----------------------------------------------------------------------------
  49
  50 // define this to use wxExecute in the exec tests, otherwise just use system
  51 #define USE_EXECUTE
  52
  53 #ifdef USE_EXECUTE
  54     #define EXEC(cmd) wxExecute((cmd), wxEXEC_SYNC)
  55 #else
  56     #define EXEC(cmd) system(cmd)
  57 #endif
  58
  59 class MyThread;
  60 WX_DEFINE_ARRAY_PTR(wxThread *, wxArrayThread);
  61
  62 // ----------------------------------------------------------------------------
  63 // the application object
  64 // ----------------------------------------------------------------------------
  65
  66 class MyApp : public wxApp
  67 {
  68 public:
  69     MyApp();
  70     virtual ~MyApp(){};
  71
  72     virtual bool OnInit();
  73
  74     // critical section protects access to all of the fields below
  75     wxCriticalSection m_critsect;
  76
  77     // all the threads currently alive - as soon as the thread terminates, it's
  78     // removed from the array
  79     wxArrayThread m_threads;
  80
  81     // semaphore used to wait for the threads to exit, see MyFrame::OnQuit()
  82     wxSemaphore m_semAllDone;
  83
  84     // indicates that we're shutting down and all threads should exit
  85     bool m_shuttingDown;
  86 };
  87
  88 // ----------------------------------------------------------------------------
  89 // the main application frame
  90 // ----------------------------------------------------------------------------
  91
  92 class MyFrame : public wxFrame,
  93                 private wxLog
  94 {
  95 public:
  96     // ctor
  97     MyFrame(const wxString& title);
  98     virtual ~MyFrame();
  99
 100     // accessors for MyWorkerThread (called in its context!)
 101     bool Cancelled();
 102
 103 protected:
 104     virtual void DoLogRecord(wxLogLevel level,
 105                              const wxString& msg,
 106                              const wxLogRecordInfo& info);
 107
 108 private:
 109     // event handlers
 110     // --------------
 111
 112     void OnQuit(wxCommandEvent& event);
 113     void OnClear(wxCommandEvent& event);
 114
 115     void OnStartThread(wxCommandEvent& event);
 116     void OnStartThreads(wxCommandEvent& event);
 117     void OnStopThread(wxCommandEvent& event);
 118     void OnPauseThread(wxCommandEvent& event);
 119     void OnResumeThread(wxCommandEvent& event);
 120
 121     void OnStartWorker(wxCommandEvent& event);
 122     void OnExecMain(wxCommandEvent& event);
 123     void OnStartGUIThread(wxCommandEvent& event);
 124
 125     void OnShowCPUs(wxCommandEvent& event);
 126     void OnAbout(wxCommandEvent& event);
 127
 128     void OnIdle(wxIdleEvent &event);
 129     void OnWorkerEvent(wxThreadEvent& event);
 130     void OnUpdateWorker(wxUpdateUIEvent& event);
 131
 132
 133     // logging helper
 134     void DoLogLine(wxTextCtrl *text,
 135                    const wxString& timestr,
 136                    const wxString& threadstr,
 137                    const wxString& msg);
 138
 139
 140     // thread helper functions
 141     // -----------------------
 142
 143     // helper function - creates a new thread (but doesn't run it)
 144     MyThread *CreateThread();
 145
 146     // update display in our status bar: called during idle handling
 147     void UpdateThreadStatus();
 148
 149
 150     // internal variables
 151     // ------------------
 152
 153     // just some place to put our messages in
 154     wxTextCtrl *m_txtctrl;
 155
 156     // old log target, we replace it with one using m_txtctrl during this
 157     // frame life time
 158     wxLog *m_oldLogger;
 159
 160     // the array of pending messages to be displayed and the critical section
 161     // protecting it
 162     wxArrayString m_messages;
 163     wxCriticalSection m_csMessages;
 164
 165     // remember the number of running threads and total number of threads
 166     size_t m_nRunning,
 167            m_nCount;
 168
 169     // the progress dialog which we show while worker thread is running
 170     wxProgressDialog *m_dlgProgress;
 171
 172     // was the worker thread cancelled by user?
 173     bool m_cancelled;
 174     wxCriticalSection m_csCancelled;        // protects m_cancelled
 175
 176     DECLARE_EVENT_TABLE()
 177 };
 178
 179 // ----------------------------------------------------------------------------
 180 // constants
 181 // ----------------------------------------------------------------------------
 182
 183 // ID for the menu commands
 184 enum
 185 {
 186     THREAD_QUIT  = wxID_EXIT,
 187     THREAD_ABOUT = wxID_ABOUT,
 188     THREAD_TEXT          = 101,
 189     THREAD_CLEAR,
 190     THREAD_START_THREAD  = 201,
 191     THREAD_START_THREADS,
 192     THREAD_STOP_THREAD,
 193     THREAD_PAUSE_THREAD,
 194     THREAD_RESUME_THREAD,
 195
 196     THREAD_START_WORKER,
 197     THREAD_EXEC_MAIN,
 198     THREAD_START_GUI_THREAD,
 199
 200     THREAD_SHOWCPUS,
 201
 202     WORKER_EVENT = wxID_HIGHEST+1,   // this one gets sent from MyWorkerThread
 203     GUITHREAD_EVENT                  // this one gets sent from MyGUIThread
 204 };
 205
 206 // ----------------------------------------------------------------------------
 207 // a simple thread
 208 // ----------------------------------------------------------------------------
 209
 210 class MyThread : public wxThread
 211 {
 212 public:
 213     MyThread();
 214     virtual ~MyThread();
 215
 216     // thread execution starts here
 217     virtual void *Entry();
 218
 219 public:
 220     unsigned m_count;
 221 };
 222
 223 // ----------------------------------------------------------------------------
 224 // a worker thread
 225 // ----------------------------------------------------------------------------
 226
 227 class MyWorkerThread : public wxThread
 228 {
 229 public:
 230     MyWorkerThread(MyFrame *frame);
 231
 232     // thread execution starts here
 233     virtual void *Entry();
 234
 235     // called when the thread exits - whether it terminates normally or is
 236     // stopped with Delete() (but not when it is Kill()ed!)
 237     virtual void OnExit();
 238
 239 public:
 240     MyFrame *m_frame;
 241     unsigned m_count;
 242 };
 243
 244 // ----------------------------------------------------------------------------
 245 // a thread which executes GUI calls using wxMutexGuiEnter/Leave
 246 // ----------------------------------------------------------------------------
 247
 248 #define GUITHREAD_BMP_SIZE          300
 249 #define GUITHREAD_NUM_UPDATES       50
 250 class MyImageDialog;
 251
 252 class MyGUIThread : public wxThread
 253 {
 254 public:
 255     MyGUIThread(MyImageDialog *dlg) : wxThread(wxTHREAD_JOINABLE)
 256     {
 257         m_dlg = dlg;
 258     }
 259
 260     virtual ExitCode Entry();
 261
 262 private:
 263     MyImageDialog *m_dlg;
 264 };
 265
 266 // ----------------------------------------------------------------------------
 267 // an helper dialog used by MyFrame::OnStartGUIThread
 268 // ----------------------------------------------------------------------------
 269
 270 class MyImageDialog: public wxDialog
 271 {
 272 public:
 273     // ctor
 274     MyImageDialog(wxFrame *frame);
 275     ~MyImageDialog();
 276
 277     // stuff used by MyGUIThread:
 278     wxBitmap m_bmp;    // the bitmap drawn by MyGUIThread
 279     wxCriticalSection m_csBmp;        // protects m_bmp
 280
 281 private:
 282     void OnGUIThreadEvent(wxThreadEvent& event);
 283     void OnPaint(wxPaintEvent&);
 284
 285     MyGUIThread m_thread;
 286     int m_nCurrentProgress;
 287
 288     DECLARE_EVENT_TABLE()
 289 };
 290
 291 // ============================================================================
 292 // implementation
 293 // ============================================================================
 294
 295 // ----------------------------------------------------------------------------
 296 // the application class
 297 // ----------------------------------------------------------------------------
 298
 299 // Create a new application object
 300 IMPLEMENT_APP(MyApp)
 301
 302 MyApp::MyApp()
 303 {
 304     m_shuttingDown = false;
 305 }
 306
 307 // `Main program' equivalent, creating windows and returning main app frame
 308 bool MyApp::OnInit()
 309 {
 310     if ( !wxApp::OnInit() )
 311         return false;
 312
 313     // uncomment this to get some debugging messages from the trace code
 314     // on the console (or just set WXTRACE env variable to include "thread")
 315     wxLog::AddTraceMask("thread");
 316
 317     // Create the main frame window
 318     new MyFrame("wxWidgets threads sample");
 319
 320     return true;
 321 }
 322
 323 // ----------------------------------------------------------------------------
 324 // MyFrame
 325 // ----------------------------------------------------------------------------
 326
 327 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
 328     EVT_MENU(THREAD_QUIT, MyFrame::OnQuit)
 329     EVT_MENU(THREAD_CLEAR, MyFrame::OnClear)
 330     EVT_MENU(THREAD_START_THREAD, MyFrame::OnStartThread)
 331     EVT_MENU(THREAD_START_THREADS, MyFrame::OnStartThreads)
 332     EVT_MENU(THREAD_STOP_THREAD, MyFrame::OnStopThread)
 333     EVT_MENU(THREAD_PAUSE_THREAD, MyFrame::OnPauseThread)
 334     EVT_MENU(THREAD_RESUME_THREAD, MyFrame::OnResumeThread)
 335
 336     EVT_MENU(THREAD_START_WORKER, MyFrame::OnStartWorker)
 337     EVT_MENU(THREAD_EXEC_MAIN, MyFrame::OnExecMain)
 338     EVT_MENU(THREAD_START_GUI_THREAD, MyFrame::OnStartGUIThread)
 339
 340     EVT_MENU(THREAD_SHOWCPUS, MyFrame::OnShowCPUs)
 341     EVT_MENU(THREAD_ABOUT, MyFrame::OnAbout)
 342
 343     EVT_UPDATE_UI(THREAD_START_WORKER, MyFrame::OnUpdateWorker)
 344     EVT_THREAD(WORKER_EVENT, MyFrame::OnWorkerEvent)
 345     EVT_IDLE(MyFrame::OnIdle)
 346 END_EVENT_TABLE()
 347
 348 // My frame constructor
 349 MyFrame::MyFrame(const wxString& title)
 350        : wxFrame(NULL, wxID_ANY, title)
 351 {
 352     m_oldLogger = wxLog::GetActiveTarget();
 353
 354     SetIcon(wxIcon(sample_xpm));
 355
 356     // Make a menubar
 357     wxMenuBar *menuBar = new wxMenuBar;
 358
 359     wxMenu *menuFile = new wxMenu;
 360     menuFile->Append(THREAD_CLEAR, _T("&Clear log\tCtrl-L"));
 361     menuFile->AppendSeparator();
 362     menuFile->Append(THREAD_QUIT, _T("E&xit\tAlt-X"));
 363     menuBar->Append(menuFile, _T("&File"));
 364
 365     wxMenu *menuThread = new wxMenu;
 366     menuThread->Append(THREAD_START_THREAD, _T("&Start a new thread\tCtrl-N"));
 367     menuThread->Append(THREAD_START_THREADS, _T("Start &many threads at once"));
 368     menuThread->Append(THREAD_STOP_THREAD, _T("S&top the last spawned thread\tCtrl-S"));
 369     menuThread->AppendSeparator();
 370     menuThread->Append(THREAD_PAUSE_THREAD, _T("&Pause the last spawned running thread\tCtrl-P"));
 371     menuThread->Append(THREAD_RESUME_THREAD, _T("&Resume the first suspended thread\tCtrl-R"));
 372     menuThread->AppendSeparator();
 373     menuThread->Append(THREAD_START_WORKER, _T("Start a &worker thread\tCtrl-W"));
 374     menuThread->Append(THREAD_EXEC_MAIN, _T("&Launch a program from main thread\tF5"));
 375     menuThread->Append(THREAD_START_GUI_THREAD, _T("Launch a &GUI thread\tF6"));
 376     menuBar->Append(menuThread, _T("&Thread"));
 377
 378     wxMenu *menuHelp = new wxMenu;
 379     menuHelp->Append(THREAD_SHOWCPUS, _T("&Show CPU count"));
 380     menuHelp->AppendSeparator();
 381     menuHelp->Append(THREAD_ABOUT, _T("&About..."));
 382     menuBar->Append(menuHelp, _T("&Help"));
 383
 384     SetMenuBar(menuBar);
 385
 386     m_nRunning = m_nCount = 0;
 387
 388     m_dlgProgress = NULL;
 389
 390 #if wxUSE_STATUSBAR
 391     CreateStatusBar(2);
 392 #endif // wxUSE_STATUSBAR
 393
 394     // create the logging text control and a header showing the meaning of the
 395     // different columns
 396     wxTextCtrl *header = new wxTextCtrl(this, wxID_ANY, "",
 397                                         wxDefaultPosition, wxDefaultSize,
 398                                         wxTE_READONLY);
 399     DoLogLine(header, "  Time", " Thread", "Message");
 400     m_txtctrl = new wxTextCtrl(this, wxID_ANY, "",
 401                                wxDefaultPosition, wxDefaultSize,
 402                                wxTE_MULTILINE | wxTE_READONLY);
 403     wxLog::SetActiveTarget(this);
 404
 405     // use fixed width font to align output in nice columns
 406     wxFont font(wxNORMAL_FONT->GetPointSize(), wxFONTFAMILY_TELETYPE,
 407                 wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
 408     header->SetFont(font);
 409     m_txtctrl->SetFont(font);
 410
 411     m_txtctrl->SetFocus();
 412
 413     // layout and show the frame
 414     wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 415     sizer->Add(header, wxSizerFlags().Expand());
 416     sizer->Add(m_txtctrl, wxSizerFlags(1).Expand());
 417     SetSizer(sizer);
 418
 419     SetSize(600, 350);
 420     Show();
 421 }
 422
 423 MyFrame::~MyFrame()
 424 {
 425     wxLog::SetActiveTarget(m_oldLogger);
 426
 427     // NB: although the OS will terminate all the threads anyhow when the main
 428     //     one exits, it's good practice to do it ourselves -- even if it's not
 429     //     completely trivial in this example
 430
 431     // tell all the threads to terminate: note that they can't terminate while
 432     // we're deleting them because they will block in their OnExit() -- this is
 433     // important as otherwise we might access invalid array elements
 434
 435     {
 436         wxCriticalSectionLocker locker(wxGetApp().m_critsect);
 437
 438         // check if we have any threads running first
 439         const wxArrayThread& threads = wxGetApp().m_threads;
 440         size_t count = threads.GetCount();
 441
 442         if ( !count )
 443             return;
 444
 445         // set the flag indicating that all threads should exit
 446         wxGetApp().m_shuttingDown = true;
 447     }
 448
 449     // now wait for them to really terminate
 450     wxGetApp().m_semAllDone.Wait();
 451 }
 452
 453 void
 454 MyFrame::DoLogLine(wxTextCtrl *text,
 455                    const wxString& timestr,
 456                    const wxString& threadstr,
 457                    const wxString& msg)
 458 {
 459     text->AppendText(wxString::Format("%9s %10s %s", timestr, threadstr, msg));
 460 }
 461
 462 void
 463 MyFrame::DoLogRecord(wxLogLevel level,
 464                      const wxString& msg,
 465                      const wxLogRecordInfo& info)
 466 {
 467     // let the default GUI logger treat warnings and errors as they should be
 468     // more noticeable than just another line in the log window and also trace
 469     // messages as there may be too many of them
 470     if ( level <= wxLOG_Warning || level == wxLOG_Trace )
 471     {
 472         m_oldLogger->LogRecord(level, msg, info);
 473         return;
 474     }
 475
 476     DoLogLine
 477     (
 478         m_txtctrl,
 479         wxDateTime(info.timestamp).FormatISOTime(),
 480         info.threadId == wxThread::GetMainId()
 481             ? wxString("main")
 482             : wxString::Format("%x", info.threadId),
 483         msg + "\n"
 484     );
 485 }
 486
 487 MyThread *MyFrame::CreateThread()
 488 {
 489     MyThread *thread = new MyThread;
 490
 491     if ( thread->Create() != wxTHREAD_NO_ERROR )
 492     {
 493         wxLogError(wxT("Can't create thread!"));
 494     }
 495
 496     wxCriticalSectionLocker enter(wxGetApp().m_critsect);
 497     wxGetApp().m_threads.Add(thread);
 498
 499     return thread;
 500 }
 501
 502 void MyFrame::UpdateThreadStatus()
 503 {
 504     wxCriticalSectionLocker enter(wxGetApp().m_critsect);
 505
 506     // update the counts of running/total threads
 507     size_t nRunning = 0,
 508            nCount = wxGetApp().m_threads.Count();
 509     for ( size_t n = 0; n < nCount; n++ )
 510     {
 511         if ( wxGetApp().m_threads[n]->IsRunning() )
 512             nRunning++;
 513     }
 514
 515     if ( nCount != m_nCount || nRunning != m_nRunning )
 516     {
 517         m_nRunning = nRunning;
 518         m_nCount = nCount;
 519
 520         wxLogStatus(this, wxT("%u threads total, %u running."), unsigned(nCount), unsigned(nRunning));
 521     }
 522     //else: avoid flicker - don't print anything
 523 }
 524
 525 bool MyFrame::Cancelled()
 526 {
 527     wxCriticalSectionLocker lock(m_csCancelled);
 528
 529     return m_cancelled;
 530 }
 531
 532 // ----------------------------------------------------------------------------
 533 // MyFrame - event handlers
 534 // ----------------------------------------------------------------------------
 535
 536 void MyFrame::OnStartThreads(wxCommandEvent& WXUNUSED(event) )
 537 {
 538     static long s_num;
 539
 540     s_num = wxGetNumberFromUser(_T("How many threads to start: "), _T(""),
 541                                 _T("wxThread sample"), s_num, 1, 10000, this);
 542     if ( s_num == -1 )
 543     {
 544         s_num = 10;
 545
 546         return;
 547     }
 548
 549     unsigned count = unsigned(s_num), n;
 550
 551     wxArrayThread threads;
 552
 553     // first create them all...
 554     for ( n = 0; n < count; n++ )
 555     {
 556         wxThread *thr = CreateThread();
 557
 558         // we want to show the effect of SetPriority(): the first thread will
 559         // have the lowest priority, the second - the highest, all the rest
 560         // the normal one
 561         if ( n == 0 )
 562             thr->SetPriority(WXTHREAD_MIN_PRIORITY);
 563         else if ( n == 1 )
 564             thr->SetPriority(WXTHREAD_MAX_PRIORITY);
 565         else
 566             thr->SetPriority(WXTHREAD_DEFAULT_PRIORITY);
 567
 568         threads.Add(thr);
 569     }
 570
 571 #if wxUSE_STATUSBAR
 572     wxString msg;
 573     msg.Printf(wxT("%d new threads created."), count);
 574     SetStatusText(msg, 1);
 575 #endif // wxUSE_STATUSBAR
 576
 577     // ...and then start them
 578     for ( n = 0; n < count; n++ )
 579     {
 580         threads[n]->Run();
 581     }
 582 }
 583
 584 void MyFrame::OnStartThread(wxCommandEvent& WXUNUSED(event) )
 585 {
 586     MyThread *thread = CreateThread();
 587
 588     if ( thread->Run() != wxTHREAD_NO_ERROR )
 589     {
 590         wxLogError(wxT("Can't start thread!"));
 591     }
 592
 593 #if wxUSE_STATUSBAR
 594     SetStatusText(_T("New thread started."), 1);
 595 #endif // wxUSE_STATUSBAR
 596 }
 597
 598 void MyFrame::OnStopThread(wxCommandEvent& WXUNUSED(event) )
 599 {
 600     wxCriticalSectionLocker enter(wxGetApp().m_critsect);
 601
 602     // stop the last thread
 603     if ( wxGetApp().m_threads.IsEmpty() )
 604     {
 605         wxLogError(wxT("No thread to stop!"));
 606     }
 607     else
 608     {
 609         wxGetApp().m_threads.Last()->Delete();
 610
 611 #if wxUSE_STATUSBAR
 612         SetStatusText(_T("Last thread stopped."), 1);
 613 #endif // wxUSE_STATUSBAR
 614     }
 615 }
 616
 617 void MyFrame::OnResumeThread(wxCommandEvent& WXUNUSED(event) )
 618 {
 619     wxCriticalSectionLocker enter(wxGetApp().m_critsect);
 620
 621     // resume first suspended thread
 622     size_t n = 0, count = wxGetApp().m_threads.Count();
 623     while ( n < count && !wxGetApp().m_threads[n]->IsPaused() )
 624         n++;
 625
 626     if ( n == count )
 627     {
 628         wxLogError(wxT("No thread to resume!"));
 629     }
 630     else
 631     {
 632         wxGetApp().m_threads[n]->Resume();
 633
 634 #if wxUSE_STATUSBAR
 635         SetStatusText(_T("Thread resumed."), 1);
 636 #endif // wxUSE_STATUSBAR
 637     }
 638 }
 639
 640 void MyFrame::OnPauseThread(wxCommandEvent& WXUNUSED(event) )
 641 {
 642     wxCriticalSectionLocker enter(wxGetApp().m_critsect);
 643
 644     // pause last running thread
 645     int n = wxGetApp().m_threads.Count() - 1;
 646     while ( n >= 0 && !wxGetApp().m_threads[n]->IsRunning() )
 647         n--;
 648
 649     if ( n < 0 )
 650     {
 651         wxLogError(wxT("No thread to pause!"));
 652     }
 653     else
 654     {
 655         wxGetApp().m_threads[n]->Pause();
 656
 657 #if wxUSE_STATUSBAR
 658         SetStatusText(_T("Thread paused."), 1);
 659 #endif // wxUSE_STATUSBAR
 660     }
 661 }
 662
 663 void MyFrame::OnIdle(wxIdleEvent& event)
 664 {
 665     UpdateThreadStatus();
 666
 667     event.Skip();
 668 }
 669
 670 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event) )
 671 {
 672     Close(true);
 673 }
 674
 675 void MyFrame::OnExecMain(wxCommandEvent& WXUNUSED(event))
 676 {
 677     wxString cmd = wxGetTextFromUser("Please enter the command to execute",
 678                                      "Enter command",
 679 #ifdef __WXMSW__
 680                                      "notepad",
 681 #else
 682                                      "/bin/echo \"Message from another process\"",
 683 #endif
 684                                      this);
 685     if (cmd.IsEmpty())
 686         return;     // user clicked cancel
 687
 688     wxLogMessage(wxT("The exit code from the main program is %ld"),
 689                  EXEC(cmd));
 690 }
 691
 692 void MyFrame::OnShowCPUs(wxCommandEvent& WXUNUSED(event))
 693 {
 694     wxString msg;
 695
 696     int nCPUs = wxThread::GetCPUCount();
 697     switch ( nCPUs )
 698     {
 699         case -1:
 700             msg = _T("Unknown number of CPUs");
 701             break;
 702
 703         case 0:
 704             msg = _T("WARNING: you're running without any CPUs!");
 705             break;
 706
 707         case 1:
 708             msg = _T("This system only has one CPU.");
 709             break;
 710
 711         default:
 712             msg.Printf(wxT("This system has %d CPUs"), nCPUs);
 713     }
 714
 715     wxLogMessage(msg);
 716 }
 717
 718 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event) )
 719 {
 720     wxMessageDialog dialog(this,
 721                            _T("wxWidgets multithreaded application sample\n")
 722                            _T("(c) 1998 Julian Smart, Guilhem Lavaux\n")
 723                            _T("(c) 2000 Robert Roebling\n")
 724                            _T("(c) 1999,2009 Vadim Zeitlin"),
 725                            _T("About wxThread sample"),
 726                            wxOK | wxICON_INFORMATION);
 727
 728     dialog.ShowModal();
 729 }
 730
 731 void MyFrame::OnClear(wxCommandEvent& WXUNUSED(event))
 732 {
 733     m_txtctrl->Clear();
 734 }
 735
 736 void MyFrame::OnUpdateWorker(wxUpdateUIEvent& event)
 737 {
 738     event.Enable( m_dlgProgress == NULL );
 739 }
 740
 741 void MyFrame::OnStartWorker(wxCommandEvent& WXUNUSED(event))
 742 {
 743     MyWorkerThread *thread = new MyWorkerThread(this);
 744
 745     if ( thread->Create() != wxTHREAD_NO_ERROR )
 746     {
 747         wxLogError(wxT("Can't create thread!"));
 748         return;
 749     }
 750
 751     m_dlgProgress = new wxProgressDialog
 752                         (
 753                          _T("Progress dialog"),
 754                          _T("Wait until the thread terminates or press [Cancel]"),
 755                          100,
 756                          this,
 757                          wxPD_CAN_ABORT |
 758                          wxPD_APP_MODAL |
 759                          wxPD_ELAPSED_TIME |
 760                          wxPD_ESTIMATED_TIME |
 761                          wxPD_REMAINING_TIME
 762                         );
 763
 764     // thread is not running yet, no need for crit sect
 765     m_cancelled = false;
 766
 767     thread->Run();
 768 }
 769
 770 void MyFrame::OnWorkerEvent(wxThreadEvent& event)
 771 {
 772     int n = event.GetInt();
 773     if ( n == -1 )
 774     {
 775         m_dlgProgress->Destroy();
 776         m_dlgProgress = (wxProgressDialog *)NULL;
 777
 778         // the dialog is aborted because the event came from another thread, so
 779         // we may need to wake up the main event loop for the dialog to be
 780         // really closed
 781         wxWakeUpIdle();
 782     }
 783     else
 784     {
 785         if ( !m_dlgProgress->Update(n) )
 786         {
 787             wxCriticalSectionLocker lock(m_csCancelled);
 788
 789             m_cancelled = true;
 790         }
 791     }
 792 }
 793
 794 void MyFrame::OnStartGUIThread(wxCommandEvent& WXUNUSED(event))
 795 {
 796     // we use this to check that disabling logging only affects the main thread
 797     // but the messages from the worker thread will still be logged
 798     wxLogNull noLog;
 799     wxLogMessage("You shouldn't see this message because of wxLogNull");
 800
 801     MyImageDialog dlg(this);
 802
 803     dlg.ShowModal();
 804 }
 805
 806
 807 // ----------------------------------------------------------------------------
 808 // MyImageDialog
 809 // ----------------------------------------------------------------------------
 810
 811 BEGIN_EVENT_TABLE(MyImageDialog, wxDialog)
 812     EVT_THREAD(GUITHREAD_EVENT, MyImageDialog::OnGUIThreadEvent)
 813     EVT_PAINT(MyImageDialog::OnPaint)
 814 END_EVENT_TABLE()
 815
 816 MyImageDialog::MyImageDialog(wxFrame *parent)
 817     : wxDialog(parent, wxID_ANY, "Image created by a secondary thread",
 818                wxDefaultPosition, wxSize(GUITHREAD_BMP_SIZE,GUITHREAD_BMP_SIZE)*1.5, wxDEFAULT_DIALOG_STYLE),
 819       m_thread(this)
 820 {
 821     m_nCurrentProgress = 0;
 822
 823     CentreOnScreen();
 824
 825     // NOTE: no need to lock m_csBmp until the thread isn't started:
 826
 827     // create the bitmap
 828     if (!m_bmp.Create(GUITHREAD_BMP_SIZE,GUITHREAD_BMP_SIZE) || !m_bmp.IsOk())
 829     {
 830         wxLogError("Couldn't create the bitmap!");
 831         return;
 832     }
 833
 834     // clean it
 835     wxMemoryDC dc(m_bmp);
 836     dc.SetBackground(*wxBLACK_BRUSH);
 837     dc.Clear();
 838
 839     // draw the bitmap from a secondary thread
 840     if ( m_thread.Create() != wxTHREAD_NO_ERROR ||
 841          m_thread.Run() != wxTHREAD_NO_ERROR )
 842     {
 843         wxLogError(wxT("Can't create/run thread!"));
 844         return;
 845     }
 846 }
 847
 848 MyImageDialog::~MyImageDialog()
 849 {
 850     // in case our thread is still running and for some reason we are destroyed,
 851     // do wait for the thread to complete as it assumes that its MyImageDialog
 852     // pointer is always valid
 853     m_thread.Delete();
 854 }
 855
 856 void MyImageDialog::OnGUIThreadEvent(wxThreadEvent& event)
 857 {
 858     m_nCurrentProgress = int(((float)event.GetInt()*100)/GUITHREAD_NUM_UPDATES);
 859
 860     Refresh();
 861 }
 862
 863 void MyImageDialog::OnPaint(wxPaintEvent& WXUNUSED(evt))
 864 {
 865     wxPaintDC dc(this);
 866
 867     const wxSize& sz = dc.GetSize();
 868
 869     {
 870         // paint the bitmap
 871         wxCriticalSectionLocker locker(m_csBmp);
 872         dc.DrawBitmap(m_bmp, (sz.GetWidth()-GUITHREAD_BMP_SIZE)/2,
 873                              (sz.GetHeight()-GUITHREAD_BMP_SIZE)/2);
 874     }
 875
 876     // paint a sort of progress bar with a 10px border:
 877     dc.SetBrush(*wxRED_BRUSH);
 878     dc.DrawRectangle(10,10, m_nCurrentProgress*(sz.GetWidth()-20)/100,30);
 879     dc.SetTextForeground(*wxBLUE);
 880     dc.DrawText(wxString::Format("%d%%", m_nCurrentProgress),
 881                 (sz.GetWidth()-dc.GetCharWidth()*2)/2,
 882                 25-dc.GetCharHeight()/2);
 883 }
 884
 885 // ----------------------------------------------------------------------------
 886 // MyThread
 887 // ----------------------------------------------------------------------------
 888
 889 MyThread::MyThread()
 890         : wxThread()
 891 {
 892     m_count = 0;
 893 }
 894
 895 MyThread::~MyThread()
 896 {
 897     wxCriticalSectionLocker locker(wxGetApp().m_critsect);
 898
 899     wxArrayThread& threads = wxGetApp().m_threads;
 900     threads.Remove(this);
 901
 902     if ( threads.IsEmpty() )
 903     {
 904         // signal the main thread that there are no more threads left if it is
 905         // waiting for us
 906         if ( wxGetApp().m_shuttingDown )
 907         {
 908             wxGetApp().m_shuttingDown = false;
 909
 910             wxGetApp().m_semAllDone.Post();
 911         }
 912     }
 913 }
 914
 915 wxThread::ExitCode MyThread::Entry()
 916 {
 917     wxLogMessage("Thread started (priority = %u).", GetPriority());
 918
 919     for ( m_count = 0; m_count < 10; m_count++ )
 920     {
 921         // check if the application is shutting down: in this case all threads
 922         // should stop a.s.a.p.
 923         {
 924             wxCriticalSectionLocker locker(wxGetApp().m_critsect);
 925             if ( wxGetApp().m_shuttingDown )
 926                 return NULL;
 927         }
 928
 929         // check if just this thread was asked to exit
 930         if ( TestDestroy() )
 931             break;
 932
 933         wxLogMessage("Thread progress: %u", m_count);
 934
 935         // wxSleep() can't be called from non-GUI thread!
 936         wxThread::Sleep(1000);
 937     }
 938
 939     wxLogMessage("Thread finished.");
 940
 941     return NULL;
 942 }
 943
 944
 945 // ----------------------------------------------------------------------------
 946 // MyWorkerThread
 947 // ----------------------------------------------------------------------------
 948
 949 // define this symbol to 1 to test if the YieldFor() call in the wxProgressDialog::Update
 950 // function provokes a race condition in which the second wxThreadEvent posted by
 951 // MyWorkerThread::Entry is processed by the YieldFor() call of wxProgressDialog::Update
 952 // and results in the destruction of the progress dialog itself, resulting in a crash later.
 953 #define TEST_YIELD_RACE_CONDITION       0
 954
 955 MyWorkerThread::MyWorkerThread(MyFrame *frame)
 956         : wxThread()
 957 {
 958     m_frame = frame;
 959     m_count = 0;
 960 }
 961
 962 void MyWorkerThread::OnExit()
 963 {
 964 }
 965
 966 wxThread::ExitCode MyWorkerThread::Entry()
 967 {
 968 #if TEST_YIELD_RACE_CONDITION
 969     if ( TestDestroy() )
 970         return NULL;
 971
 972     wxThreadEvent event( wxEVT_COMMAND_THREAD, WORKER_EVENT );
 973
 974     event.SetInt( 50 );
 975     wxQueueEvent( m_frame, event.Clone() );
 976
 977     event.SetInt(-1);
 978     wxQueueEvent( m_frame, event.Clone() );
 979 #else
 980     for ( m_count = 0; !m_frame->Cancelled() && (m_count < 100); m_count++ )
 981     {
 982         // check if we were asked to exit
 983         if ( TestDestroy() )
 984             break;
 985
 986         // create any type of command event here
 987         wxThreadEvent event( wxEVT_COMMAND_THREAD, WORKER_EVENT );
 988         event.SetInt( m_count );
 989
 990         // send in a thread-safe way
 991         wxQueueEvent( m_frame, event.Clone() );
 992
 993         wxMilliSleep(200);
 994     }
 995
 996     wxThreadEvent event( wxEVT_COMMAND_THREAD, WORKER_EVENT );
 997     event.SetInt(-1); // that's all
 998     wxQueueEvent( m_frame, event.Clone() );
 999 #endif
1000
1001     return NULL;
1002 }
1003
1004
1005 // ----------------------------------------------------------------------------
1006 // MyGUIThread
1007 // ----------------------------------------------------------------------------
1008
1009 wxThread::ExitCode MyGUIThread::Entry()
1010 {
1011     // uncomment this to check that disabling logging here does disable it for
1012     // this thread -- but not the main one if you also comment out wxLogNull
1013     // line in MyFrame::OnStartGUIThread()
1014     //wxLogNull noLog;
1015
1016     // this goes to the main window
1017     wxLogMessage("GUI thread starting");
1018
1019     // use a thread-specific log target for this thread to show that its
1020     // messages don't appear in the main window while it runs
1021     wxLogBuffer logBuf;
1022     wxLog::SetThreadActiveTarget(&logBuf);
1023
1024     for (int i=0; i<GUITHREAD_NUM_UPDATES && !TestDestroy(); i++)
1025     {
1026         // inform the GUI toolkit that we're going to use GUI functions
1027         // from a secondary thread:
1028         wxMutexGuiEnter();
1029
1030         {
1031             wxCriticalSectionLocker lock(m_dlg->m_csBmp);
1032
1033             // draw some more stuff on the bitmap
1034             wxMemoryDC dc(m_dlg->m_bmp);
1035             dc.SetBrush((i%2)==0 ? *wxBLUE_BRUSH : *wxGREEN_BRUSH);
1036             dc.DrawRectangle(rand()%GUITHREAD_BMP_SIZE, rand()%GUITHREAD_BMP_SIZE, 30, 30);
1037
1038             // simulate long drawing time:
1039             wxMilliSleep(200);
1040         }
1041
1042         // if we don't release the GUI mutex the MyImageDialog won't be able to refresh
1043         wxMutexGuiLeave();
1044
1045         // notify the dialog that another piece of our masterpiece is complete:
1046         wxThreadEvent event( wxEVT_COMMAND_THREAD, GUITHREAD_EVENT );
1047         event.SetInt(i+1);
1048         wxQueueEvent( m_dlg, event.Clone() );
1049
1050         if ( !((i + 1) % 10) )
1051         {
1052             // this message will go to the buffer
1053             wxLogMessage("Step #%d.", i + 1);
1054         }
1055
1056         // give the main thread the time to refresh before we lock the GUI mutex again
1057         // FIXME: find a better way to do this!
1058         wxMilliSleep(100);
1059     }
1060
1061     // now remove the thread-specific thread target
1062     wxLog::SetThreadActiveTarget(NULL);
1063
1064     // so that this goes to the main window again
1065     wxLogMessage("GUI thread finished.");
1066
1067     return (ExitCode)0;
1068 }