Executable Container Objects for Concurrent Thread Processing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In parallel computer applications, the concurrent execution of threads can lead to data inconsistencies due to simultaneous reading and writing operations, requiring developers to manage complex dependencies and synchronization, which complicates the development and execution of parallel applications.
Innovation Solution
A method and system that utilize executable container objects and threads to process instructions concurrently, with a library providing classes for creating and managing executable objects and containers, enabling concurrent execution while managing dependencies and synchronization through conditional and non-conditional executable objects and containers.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If multiple threads execute an application in parallel, then processing speed is improved, but data consistency deteriorates due to simultaneous read and write operations
Solution Approach 1:
The patent introduces executable container objects as intermediaries between threads and executable objects. These container objects manage the concurrent access to executable objects, coordinating read and write operations to prevent data inconsistencies while allowing parallel execution to proceed.
Solution Approach 2:
The system implements feedback mechanisms where executable container objects monitor and coordinate access patterns of multiple threads. The container objects receive information about thread operations and adjust access control accordingly, ensuring data consistency is maintained through continuous coordination of concurrent operations.
2Reliability
If developers manually manage thread dependencies and synchronization, then data consistency is maintained, but development complexity increases
Solution Approach 1:
The executable container objects provide self-service functionality by automatically managing the coordination and synchronization of multiple threads accessing executable objects. The system performs dependency management and conflict resolution autonomously without requiring explicit developer intervention, thereby maintaining data consistency while reducing development complexity.
Solution Approach 2:
The patent segments the complexity of thread management by separating concerns into distinct components: executable objects contain the actual work, while executable container objects handle the coordination and synchronization logic. This segmentation allows developers to focus on business logic while the container objects manage the complex threading aspects.
3Productivity
If threads access shared data concurrently without coordination, then processing efficiency is improved, but data reliability deteriorates
Solution Approach 1:
Executable container objects serve as intermediary layers between concurrently executing threads and shared executable objects. These containers coordinate access patterns, allowing multiple threads to efficiently process data while preventing conflicting read and write operations that would compromise data reliability.
Data Source
AI summary
A method for executing an application, that includes instantiating, by a first thread, a first executable object and a second executable object, creating a first processing unit and a second processing unit, instantiating an executable container object, spawning a second thread, associating the first executable object and the second executable object with the executable container object, processing the executable container object to generate a result, and storing the result. Processing the executable container object includes associating the first executable object with the first processing unit, and associating the second executable object with the second processing unit, wherein the first thread processes executable objects associated with the first processing unit, wherein the second thread processes executable objects associated with the second processing unit, and wherein the first thread and the second thread execute concurrently.