Creating a Worker Thread for Background Processing

By: Borland Staff

Abstract: Steps to create a thread in Delphi
Problem:
Creating a Worker Thread for Background Processing

Solution:
This information in this document applies to:

* InterBase 5.x
* Delphi 32-bit

*******************************************
Steps to Create a Background Thread
*******************************************

1.Create new Application 

2.Create a descendant of TThread (we'll call it TWorkerThread).  You can do this by
    selecting the File | New menu option and choosing the "Thread Object" item. 

3.Save your unit (we'll call it WorkerThreadUnit) 

4.Add WorkerThreadUnit to interface uses section of TMainForm.  This is added to the
    interface section, opposed to the implementation section, because we are going to
    create a variable of this class and need this when declaring the main form's class. 

    { begin code snippet }
    interface 

    uses 
      WorkerThreadUnit; 
    { end code snippet }      
      
5.Create a variable of TWorkerThread.  Here is a code snippet showing a variable of
    type TWorkerThread being declared. 

    { begin code snippet }
    type 
      TMainForm = class(TForm) 
      private 
      public 
        { Public declarations } 
        workerThread: TWorkerThread; 
      end; 
    { end code snippet }            
      
6. Add TMainForm's unit (MainUnit) to the implementation section of
    WorkerThreadUnit.  We add it to the implementation section, because we will use it
    in our classes declaration, not its definition. 

    { begin code snippet }
    implementation 

      uses SysUtils, MainUnit; 
    { end code snippet }            
      
7. Fill in the Execute method of TWorkerThread to do what you want when thread is
    created.  This method will be called when you create an instance of your thread. 

    { begin code snippet }
    procedure TWorkerThread.Execute; 
    begin 
      { Place thread code here } 
      . 
      . 
      . 
    end; 
    { end code snippet }            
      
8. Create a method to be used for all your user interface code.  This needs to be in a
    separate method so that we can invoke it with the Synchronize method of the
    TThread class (we'll call it UpdateUI) 

    { begin code snippet }
    procedure TWorkerThread.UpdateUI; 
    begin 
      { do user interface stuff here } 
      . 
      . 
      . 
    end; 
    { end code snippet }            
      
9. In TWorkerThread's Execute method call the Synchronize method and pass it the
    UpdateUI method as a parameter. 

    { begin code snippet }
    procedure TWorkerThread.Execute; 
    begin 
      { Place thread code here } 
      FreeOnTerminate := true; 
      Synchronize(UpdateUI); 
    end; 
    { end code snippet }            
      
10. Now, in your main form create an instance of your TWorkerThread class where ever
      you need a new thread.  Here is an example showing an instance of our
      TWorkerThread class being created when Button1 is clicked. 

    { begin code snippet }
    procedure TMainForm.Button1Click(Sender: TObject); 
    begin 
      workerThread := TWorkerThread.Create(false); 
    end; 
    { end code snippet }           

********
Notes
********

* Delphi requires (there are a few exceptions) that all user interface code be executed in
   the context of the application's primary thread. 

* TThread provides a method called Synchronize to allow some of its methods to be
   executed in the context of the application's primary thread. 
 
* TThread is an object pascal object that encapsulates a Win32 API thread object. 
    The parameter to the TThread.Create method controls whether the thread is created
    in a suspended state.  If true is passed in then the thread will be created, but its execute
    will be suspended.  If false is passed in the thread will be created and will execute
    immediately.  In the above example I passed in false so that the worker thread would
    execute as soon as it was created. 

* The thread associated with a TThread object will be terminated as soon as the
    TThread.Execute method is done executing. 

* However, the TThread object will not automatically be destroyed when the
   underlying thread terminates.  To destroy the TThread object you can: 
        * Explicitly call the TThread.Destroy method 
        * Set the TThread's property FreeOnTerminate to true in the TThread.Execute
          method.  If FreeOnTerminate is true then the TThread object will be
          automatically destroyed when the underlying thread is terminated. 


Published on: 7/24/2000 12:00:00 AM

Server Response from: ETNASC03

Copyright© 1994 - 2013 Embarcadero Technologies, Inc. All rights reserved.