Introduction​

Xbase++ is a versatile programming language that allows developers to create multi-threaded applications easily. In this article, we will explore how to use the Thread class in Xbase++ to create and manage an operating system thread capable of executing different tasks. We will provide a code example to demonstrate how a single operating system thread, maintained by a Thread instance, can execute the class method TaskOne:run() and then proceed to execute the method TaskTwo:run().

Source Code Example​

Xbase++: 
PROCEDURE Main()
   LOCAL oThread

   // Creating an operating system thread
   oThread := Thread():new()

   // Using the thread for one task
   oThread:start( {|| TaskOne():run() } )
   oThread:synchronize( 0 )

   // Using the thread for a different task
   oThread:start( {|| TaskTwo():run() } )
   oThread:synchronize( 0 )

RETURN

/// <summary>
/// Implementation of task one
/// </summary>
CLASS TaskOne
   EXPORTED:
      CLASS METHOD run
ENDCLASS

CLASS METHOD TaskOne:run()
   ? ProcName()
RETURN SELF

/// <summary>
/// Implementation of task two
/// </summary>
CLASS TaskTwo
   EXPORTED:
      CLASS METHOD run
ENDCLASS

CLASS METHOD TaskTwo:run()
   ? ProcName()
RETURN SELF

Understanding the Thread Class​

In Xbase++, the Thread class provides a convenient way to work with operating system threads. You can create an instance of the Thread class and use this instance to execute arbitrary code.

Creating a Thread Instance​

To create a Thread instance, you call the class method Thread():new(). This initializes a new operating system thread and binds it to the instance, making it ready for execution.

Executing Tasks Using Threads​

Once you have a Thread instance, you can use it to execute tasks. In the provided code example, we have two classes, TaskOne and TaskTwo, each implementing a method named "run." We want to execute these methods using the same operating system thread sequentially.

Starting the Thread for TaskOne​

To execute TaskOne:run() using the Thread instance, we use the :start() method on the Thread instance. The :start() method takes a code block as an argument, which defines the task to be executed. In this case, we use {|| TaskOne():run() } as the code block to call the class method :run() of he class TaskOne() within the thread.
Also in this example we use oThread:synchronize(0) to ensure that the current thread waits for the operating system thread to finish executing the task

Starting the Thread for TaskTwo​

Once the first task (TaskOne:run()) is completed, we can reuse the same Thread instance to execute the TaskTwo:run() class method. Again, we use the :start() method with a code block to define the task.

Conclusion​

In this article, we've explored how to use the Xbase++ class Thread to execute multiple tasks sequentially by one thread. By creating a Thread instance and using the :start() method with code blocks, we can easily manage and execute different tasks in a multi-threaded environment. This allows for efficient and parallel processing of tasks while ensuring proper separation between them.