Thread Service Throughput via Segmented Processing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for processing multiple services using threads are inefficient, as the synchronous model leads to suspended processing and the asynchronous model restricts processing of other services while a callee service is being processed.
Innovation Solution
A computing device and method that allow a first thread to process another service while a callee service is being processed by a second thread, and upon completion, enable either the first thread or another thread to resume the unprocessed part of the caller service using a result value, thereby avoiding suspended processing and enhancing throughput.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If the synchronous model is used where the caller service waits until the callee service is finished, then the processing order is simple and easy to manage, but the thread processing the caller service is suspended resulting in low processing efficiency
Solution Approach 1:
The service processing is divided into independent segments that can be executed by different threads. The caller service is segmented into parts that can continue processing independently while the callee service is being processed by another thread, eliminating the suspension wait time while maintaining manageable processing through structured segmentation.
Solution Approach 2:
The system performs preliminary actions by pre-processing parts of the caller service that do not depend on the callee service result. This allows the thread to continue productive work before the callee service completes, rather than idling in suspension, while still maintaining clear processing management through predefined execution paths.
2Productivity
If the asynchronous model is used where the thread processes unprocessed parts of the caller service while the callee service is being processed, then processing efficiency improves, but the thread cannot process other services resulting in poor service management
Solution Approach 1:
The thread is designed with multi-functionality to both process services and manage service coordination. Instead of a single thread being limited to one service, it can process multiple services including both the caller service and other independent services, achieving both high productivity and effective service management through universal thread capabilities.
Solution Approach 2:
The system dynamically adjusts thread allocation and service processing priorities based on real-time conditions. Threads can transition between processing different services dynamically, allowing efficient resource utilization while maintaining manageable service orchestration through adaptive scheduling rather than rigid assignment.
3Ease of operation
If a single thread processes multiple services sequentially, then service processing is simple to manage, but the throughput of services is limited
Solution Approach 1:
Service processing is segmented into independent units that can be distributed across multiple threads. Each thread handles specific service segments independently, maintaining simple processing logic within each thread while achieving high overall throughput through parallel execution of segmented service units.
Solution Approach 2:
Multiple service processing capabilities are merged into a coordinated multi-threaded system. Individual threads process different service segments in parallel, and their results are merged into the final service outcome, achieving both simplified individual processing and high aggregate throughput through combining multiple processing streams.
Data Source
AI summary
A method for increasing throughputs of multiple services processed by multiple threads on conditions that the multiple services include at least a first, a second, and a third services and the multiple threads include at least a first and a second thread including steps of: (a) if the first service being processed by the first thread calls the second service, supporting the second thread to process the second service; and (b) while the second service is being processed, supporting the first thread to process the third service; and (c) if the processing of the second service is completed, supporting (i) the first thread or (ii) one or more other threads except the first thread to resume a processing of an unprocessed part of the first service, by using a result value acquired by the processing of the second service.