This is done by specifying a value of OCI_NO_MUTEX to the OCIEnvCreate() call. If the application programmer desires, this application can override this feature and maintain its own mutexing scheme. If a multithreaded application is running on a thread-safe platform, the OCI library will manage mutexing for the application on a per-environment-handle basis. Single-threaded applications which run in OCI_THREADED mode may incur performance hits. If an application is single-threaded, whether or not the platform is thread-safe, the application should pass a value of OCI_DEFAULT to OCIInitialize() or OCIEnvCreate(). Once OCIEnvCreate() is called with OCI_THREADED, all subsequent calls to OCIEnvCreate() must also be made with OCI_THREADED.Īpplications running on non-thread-safe platforms should not pass a value of OCI_THREADED to OCIInitialize() or OCIEnvCreate(). Then the application must tell the OCI layer that the application is running in multithreaded mode, by specifying OCI_THREADED for the mode parameter of the opening call to OCIEnvCreate(). In order to take advantage of thread safety, an application must be running on a thread-safe platform. In OCI, mutexes are granted on a per-environment-handle basis. The mechanism to manage data access takes the form of mutexes (mutual exclusivity locks), that ensure that no conflicts arise between multiple threads that are accessing shared resources within an application. Because of this shared access to data elements, a mechanism is required to maintain the integrity of data being accessed by multiple threads. They can access common data elements and make OCI calls in any order. Once spawned, threads run asynchronously to one another. Global and static variables are common to all threads, and a mutual exclusivity mechanism may be required to manage access to these variables from multiple threads within an application.
#LINK SEQUENTIAL PROGRAM WITH MULTITHREAD MKL CODE#
Threads share the same code and data segments but have their own program counters, machine registers, and stack. Threads are lightweight processes that exist within a larger process.
Basic Concepts of Multithreaded Development In an Oracle environment this application server is an OCI or precompiler program. The applications server (agent) is very well suited to being a multithreaded application server, with each thread serving a client application. The server tier in this scenario is an Oracle database. Typically, this relationship is a many-to-one relationship, with multiple clients sharing the same application server. The agent (or application server) processes the application logic for the client application.
In this architecture the client is concerned only with presentation services. In addition to client-server applications, where the client can be a multithreaded program, a typical use of multithreaded applications is in three-tier (also called client-agent-server) architectures. Thread Safety and Three-Tier Architectures Gains may be seen on multiprocessor systems where threads run concurrently on separate processors, and on single processor systems where overlap can occur between slower operations and faster operations. Use of multiple threads can improve program performance.Users who do not write multithreaded programs do not pay a performance penalty for using thread-safe OCI calls.When multiple threads make OCI calls, there are no side effects between threads.Multiple threads of execution can make OCI calls with the same result as successive calls made by a single thread.The implementation of thread safety in the Oracle Call Interface has the following benefits and advantages:
The following sections describe how you can use the OCI to develop multithreaded applications. Check your Oracle system-specific documentation for more information. Thread safety is not available on every platform.
0 kommentar(er)
