CORBA 2.6.1 Programmer's Guide for C++

Chapter 8. Writing Multithreaded Applications
Chapter 8. Writing Multithreaded Applications
Overview of Multithreading
Multithreading in Client Applications
Multithreading in Server Implementations
Using the NonStop CORBA Portable Threading (vthread) API
Creating and Using Threads
Using the yield(), join() and cancel() Methods
Creating and Using a Mutex
Creating and Using a Condition Variable
Saving and Retrieving Thread-Specific Data
Terminating Execution of a Thread
Detaching a Thread
Error Reporting from vthread Methods
Using a Timer for a Thread
This section describes how to make appropriate threading decisions and write multithreaded NonStop CORBA applications.
For C++ programmers, NonStop CORBA provides an object-oriented, portable API for multithreading, which is described under
Using the
NonStop CORBA Portable Threading (vthread) API.
For several examples of explicit multithreading in a NonStop CORBA application, refer to the Bank sample application. The client wrapper uses
mutexes, and the server wrapper uses condition variables. The feed program uses a timer and includes several uses of multithreading.
Multithreading in the feed program reduces the number of processes that are needed to generate workload for the application.
Overview of Multithreading
Multithreading is a programming paradigm that enables logically concurrent execution. A thread is a sequence of running code that coexists
with other threads in the same address space. Each thread has its own execution stack, but shares the process instruction space with other
threads. Having multiple threads in a process means that there are many apparently simultaneous points of execution. Multithreading simplifies
programming tasks by allowing you to write a single code sequence as if it were alone and have it run as many threads. By writing different
threads to handle different tasks, you can easily divide the process space. Multithreading can also increase the throughput of a process without
incurring the overhead of creating multiple processes.
The NonStop CORBA ORB itself is multithreaded, and it provides automatic multithreaded dispatching of requests to servants through its
implementation of the default POA threading policy, ORB_CTRL_MODEL. The same servant can be accessed by multiple threads. You can also
explicitly create additional threads in your applications. In a distributed NonStop CORBA application, you can use multithreading in the client, the
server, or both. You can use multithreading with or without server pools.
Some applications lend themselves better to multithreading than others. Multithreading can be useful when:
Interacting with another object or process that may be slow in responding
Interacting with a user who may not respond immediately
Note:
On NonStop systems, threads are not run in separate processors. To take advantage of parallel processing, use
separate processes rather than threads.
Multithreading on NonStop systems is non-preemptive.
Multithreading in Client Applications
One typical use of multithreading in NonStop CORBA client programs is to issue concurrent requests to one or more objects. When
multithreading is not used, operations are synchronous. That is, when a client performs an operation on an object, it must wait for the response
to arrive before doing any further processing. If a client application creates multiple threads, each thread can perform operations and thus have
concurrent outstanding requests.
The
feed program that is part of the Bank sample application contains a multithreaded NonStop CORBA client program.
Note:
You can use the Dynamic Invocation Interface (DII) instead of multithreading to issue asynchronous requests. In
some situations, this may be a desirable alternative to multithreading. However, using the dynamic invocation
interface generally requires more programming effort than does explicit multithreading.