Decentralized Worker Thread Execution via Utility Queue
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing software applications face inefficiencies in managing multiple threads of execution, particularly due to resource overhead and complexity introduced by centralized timer manager threads, which limits decentralized execution and oversight of worker threads.
Innovation Solution
Implementing a decentralized system where worker threads are initialized to execute work item entries from a utility list queue, allowing them to intelligently manage their execution without centralized oversight, thereby reducing resource utilization and serialization.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a centralized timer manager thread is used to manage worker threads, then thread execution can be coordinated, but system resource overhead and complexity increase
Solution Approach 1:
The patent extracts the centralized timer manager thread from the system and removes its management functions. Worker threads are initialized with direct access to the utility list queue and can independently evaluate, acquire, and execute work item entries without centralized coordination, thereby eliminating the overhead and complexity of centralized management while maintaining execution reliability
Solution Approach 2:
Worker threads are designed to be self-sufficient by directly evaluating the utility list queue for unassigned work item entries, acquiring them independently, and executing them autonomously. This self-service mechanism eliminates the need for centralized timer manager oversight, reducing system resource overhead and complexity while ensuring reliable thread execution coordination
2Reliability
If a centralized timer manager thread oversees worker threads, then execution control is maintained, but serialization is introduced
Solution Approach 1:
The patent segments the centralized execution control function into individual worker threads. Each worker thread independently evaluates the utility list queue, acquires unassigned work item entries, and executes them autonomously. This segmentation eliminates serialization by allowing multiple worker threads to operate in parallel without being bottlenecked by a centralized timer manager
Solution Approach 2:
Worker threads perform self-service by independently managing their own execution workflow: evaluating the utility list queue, acquiring suitable work item entries, and executing them without requiring centralized control. This autonomous operation eliminates serialization effects while maintaining reliable execution control across the system
Data Source
AI summary
One or more techniques and/or systems are provided for managing one or more worker threads. For example, a utility list queue may be populated with a set of work item entries for execution. A set of worker threads may be initialized to execute work item entries within the utility list queue. In an example, a worker thread may be instructed to operate in a decentralized manner, such as without guidance from a timer manager thread. The worker thread may be instructed to execute work item entries that are not assigned to other worker threads and that are expired (e.g., ready for execution). The worker thread may transition into a sleep state if the utility list queue does not comprise at least one work item entry that is unassigned and expired.