Thread-Local Software Component Instances for Pool Access
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Synchronization in software component pooling leads to bottlenecks and increased waiting times in distributed enterprise software applications, particularly during heavy loads, as multiple threads must access shared resources sequentially.
Innovation Solution
Implementing a system where threads can access software component instances either privately and unsynchronized or from a synchronized pool, depending on the type and number of components needed, to avoid synchronization delays and optimize resource usage.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Quantity of substance
If software component instances are pooled and accessed synchronously by multiple threads, then resource sharing and memory efficiency are improved, but thread waiting time and execution time increase due to synchronization bottlenecks
Solution Approach 1:
The patent segments software component access into two distinct pathways: a synchronized pooled access path for shared components and an unsynchronized private instantiation path for thread-specific components. This segmentation allows threads to choose the appropriate access method based on component type, eliminating unnecessary synchronization waiting while maintaining resource sharing benefits where applicable.
Solution Approach 2:
The patent applies different access quality characteristics to different software components based on their nature. Shared components use synchronized pooled access with strict access controls, while thread-local components use unsynchronized direct instantiation. This local differentiation optimizes performance by applying synchronization only where necessary, reducing overall thread waiting time.
2Reliability
If synchronized access to software component pool is implemented, then data consistency and thread safety are ensured, but productivity decreases due to multiple threads waiting for pool access
Solution Approach 1:
The patent divides software component access into synchronized and unsynchronized pathways, allowing threads to bypass synchronization overhead for private components while maintaining synchronized access for shared components. This segmentation preserves thread safety where needed without universally applying synchronization that would reduce productivity.
Solution Approach 2:
The patent enables threads to create and manage their own private software component instances without requiring synchronized pool access. Each thread serves its own needs through direct instantiation, eliminating the need to wait for pool availability and improving overall thread execution speed while maintaining reliability through proper access control for shared components.
3Loss of time
If private unsynchronized access to software components is allowed, then execution time is reduced by eliminating synchronization delays, but resource contention and memory usage increase
Solution Approach 1:
The patent applies unsynchronized private access only to thread-local software components that do not require sharing, while maintaining synchronized pooled access for shared components. This selective application reduces execution time for appropriate components without unnecessarily increasing resource consumption, as synchronization is maintained where resource sharing is beneficial.
Data Source
AI summary
A method is described that involves creating an instance of a software component for the substantially private use of a thread. A determination of whether to access an instance of a software component from one of a private software component instance collection and a software component instance pool is made, the private software component instance collection configured to include an instance of the software component that is not synchronized with an additional thread of the computer program, the software component instance pool configured to include an instance of the software component that is synchronized with the additional thread of the computer program, the determination based on a number of other threads accessing the software component instance pool and a complexity of whether the instance of the software component is to execute at least one of a single task and a few simple tasks.