Integrated Application Execution via Process Isolation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current methods for integrating application programs are inefficient, requiring significant development and maintenance costs, limited flexibility, and posing compatibility issues, especially when adding new functions or updating SDKs.
Innovation Solution
A method and apparatus that instantiate different application programs in separate processes, using unique identifiers to execute distinct initialization codes and construct different operating environments within a single application program installation package, allowing for flexible integration and improved development efficiency.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If application programs are integrated by packaging an SDK, then integration requirements are satisfied and development workload of integrating party is small, but integrated party needs to invest in development and maintenance of SDK resources, is not flexible enough, and SDK updating creates compatibility problems
Solution Approach 1:
The patent introduces a process identifier as an intermediary mechanism that mediates between multiple application programs. Each application program is instantiated in a separate process with its own identifier, allowing them to coexist and interact without direct integration. This resolves the contradiction by enabling flexibility (each program maintains independence) while keeping integration simple (managed through process identifiers).
Solution Approach 2:
The patent segments application programs into separate processes, each with its own context and identifier. Instead of integrating code at the application level or requiring SDK packaging, each program runs independently in its own process space. This segmentation provides flexibility while simplifying integration management through process-level isolation.
2Productivity
If application programs are integrated by code-level multiplexing, then code structure and program execution efficiency are optimized, but development and maintenance costs invested by integrating party are excessively large
Solution Approach 1:
The patent segments application programs into separate processes rather than merging code at the application level. Each program maintains its own code structure and execution context, eliminating the need for complex code-level integration work. This reduces development and maintenance costs while still achieving efficient execution through process-level management.
Solution Approach 2:
The patent creates process copies for each application program, allowing them to run independently with their own memory spaces and execution contexts. This copying approach at the process level avoids the complexity of code-level multiplexing while maintaining execution efficiency through isolated, optimized process environments.
3Adaptability or versatility
If multiple application programs are integrated into a single installation package, then integration is achieved, but memory occupation increases and may affect operating stability
Solution Approach 1:
The patent segments integrated application programs into separate processes, each with its own memory space and execution context. This process-level segmentation allows multiple programs to coexist in a single installation package while maintaining memory isolation, preventing one program from affecting the stability of others and thus preserving operating stability.
Solution Approach 2:
The patent uses process identifiers as intermediaries to manage multiple application programs within a single installation package. Each program is associated with a unique process identifier, allowing the system to distinguish and manage memory resources for each program independently. This intermediary mechanism enables integration while maintaining memory isolation for stability.
Data Source
AI summary
The present disclosure provides methods and apparatus for executing integrated application programs. An implementation class of an instantiation application program is executed in a first process, to obtain a context of a first application program including a first identifier. Or an implementation class of an instantiation application program is executed in a second process, to obtain a context of a second application program including a second identifier. It is determined whether an identifier corresponding to a current process is the first identifier or the second identifier. If the identifier corresponding to the current process is the first identifier, the first application program is executed when an initialization starts. Or, if the identifier corresponding to the current process is the second identifier, the second application program is executed when an initialization starts.