CN109976820B - Application program running method and application program framework - Google Patents
Application program running method and application program framework Download PDFInfo
- Publication number
- CN109976820B CN109976820B CN201910278412.4A CN201910278412A CN109976820B CN 109976820 B CN109976820 B CN 109976820B CN 201910278412 A CN201910278412 A CN 201910278412A CN 109976820 B CN109976820 B CN 109976820B
- Authority
- CN
- China
- Prior art keywords
- kernel
- module
- loading
- communication
- application program
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/4401—Bootstrapping
- G06F9/4403—Processor initialisation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/545—Interprogram communication where tasks reside in different layers, e.g. user- and kernel-space
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses an application program running method and an application program framework, which can realize communication between an application program and a kernel. The method is applied to an application program comprising a kernel initialization module, a kernel communication module and a service module, and comprises the following steps: loading a kernel initialization module, a kernel communication module and a service module according to a preset strategy; the kernel communication process: and the kernel communication module receives the request of the service module, calls a kernel function to process the request and returns a processing result to the service module. By adopting the embodiment of the invention, a plurality of service modules are supported to communicate with the kernel, the service modules are independent from each other and do not influence each other, and if any one service module fails to be loaded, the loading of other service modules is not influenced. The system calls ensure kernel communication, the modular design ensures independent services, and the compiling and configuration ensure code multiplexing.
Description
Technical Field
The present invention relates to computer technologies, and in particular, to an application operating method and an application architecture.
Background
In the prior art, the kernel layer and the application layer can communicate through a system call, a virtual file system and an ioctl interface:
the system calls the request of the application program to the kernel, calls the corresponding kernel function to complete the required processing, and returns the processing result to the service module.
In a file system, reading and writing of a virtual file can be used as a means for communicating with an entity in a kernel, and communication can be performed between a kernel layer and an application layer through the virtual file. Unlike ordinary files, the contents of these virtual files are created dynamically.
If a new function needs to be extended, the communication between the kernel layer and the application layer is usually realized by adding an ioctl () command.
In the three methods, the kernel layer and the application layer communicate through the virtual file system and the ioctl interface, so that the stability and the security are poor, and in some operating systems, such as a Unix operating system, the only legal choice is made during system call, and at this time, the kernel layer and the application layer cannot communicate through the virtual file system and the ioctl interface. The system calls are used for their particularity, which only exists in the system after the kernel is started, i.e. the use of the system call must be after the start. However, if there is a use of a system call in the dynamic library, even if this function is not used, the library cannot be loaded correctly until the kernel is started.
Disclosure of Invention
In order to solve the above technical problem, the present invention provides an application program running method and an application program architecture, which can implement communication between an application program and a kernel.
In order to achieve the aim of the invention, the invention provides an application program running method, which is applied to an application program comprising a kernel initialization module, a kernel communication module and a service module, and comprises a communication channel establishing process and a kernel communication process;
the communication channel establishment procedure comprises: loading a kernel initialization module, a kernel communication module and a service module according to a preset strategy;
the kernel communication process comprises the following steps: and the kernel communication module receives the request of the service module, calls a kernel function to process the request and returns a processing result to the service module.
In an exemplary embodiment, the loading the kernel initialization module includes: and carrying out kernel initialization and kernel starting.
In an exemplary embodiment, the loading the kernel communication module includes: establishing a kernel communication interface and a registration interface; the kernel communication interface is used for the application program to actively communicate with the kernel; the registration interface is used for the kernel to actively communicate with the application program.
In an exemplary embodiment, the application program comprises a plurality of business modules; the loading of the kernel initialization module, the kernel communication module and the service module according to the preset strategy comprises the following steps:
loading the kernel communication module after the kernel initialization module is loaded successfully, and sequentially loading the service modules according to a preset sequence after the kernel communication modules are loaded successfully;
when the loading of the kernel initialization module or the kernel communication module fails, the application program quits the loading; and when the loading of the service module fails, loading the next service module according to the preset sequence.
In an exemplary embodiment, the communication channel establishing process further includes: the kernel initialization module multiplexes codes in the service module; wherein the multiplexed code is implemented in the service module by a predefined macro.
In an exemplary embodiment, the kernel initialization module multiplexes code in the service module, including: the kernel initialization function in the kernel initialization module realizes parameter compilation by shielding functions except for the derived functions during compilation, and declares a scope as derived when the functions are derived.
In an exemplary embodiment, the kernel initialization module, the kernel communication module and the service module are stored in the form of a dynamically linked library.
In order to achieve the object of the present invention, the present invention further provides that the application program includes a kernel initialization module, a kernel communication module, and a service module, wherein:
the kernel initialization module is used for kernel initialization and kernel startup;
the kernel communication module is used for establishing a kernel communication interface and a registration interface; the kernel communication interface is used for the application program to actively communicate with the kernel; the registration interface is used for the kernel to actively communicate with the application program.
In an exemplary embodiment, the kernel initialization module multiplexes code in the business module; wherein the multiplexed code is implemented in the service module by a predefined macro.
In an exemplary embodiment, the kernel initialization module, the kernel communication module and the service module are stored in the form of a dynamically linked library.
Compared with the prior art, the method is applied to the application program comprising the kernel initialization module, the kernel communication module and the service module, and comprises a communication channel establishing process and a kernel communication process; the communication channel establishment procedure comprises: loading a kernel initialization module, a kernel communication module and a service module according to a preset strategy; the kernel communication process comprises the following steps: and the kernel communication module receives the request of the service module, calls a kernel function to process the request and returns a processing result to the service module. A plurality of service modules are supported to communicate with the kernel. The service modules are independent from each other and do not influence each other, and if any one service module fails to be loaded, the loading of other service modules is not influenced. The system calls ensure kernel communication, the modular design ensures independent services, and the compiling and configuration ensure code multiplexing.
Additional features and advantages of the invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by practice of the invention. The objectives and other advantages of the invention will be realized and attained by the structure particularly pointed out in the written description and claims hereof as well as the appended drawings.
Drawings
The accompanying drawings are included to provide a further understanding of the invention and are incorporated in and constitute a part of this specification, illustrate embodiments of the invention and together with the example serve to explain the principles of the invention and not to limit the invention.
Fig. 1 is a flowchart of an application running method according to a first embodiment of the present invention;
fig. 2 is a flowchart of an application running method according to a second embodiment of the present invention;
fig. 3 is a schematic structural diagram of an application architecture according to a third embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, embodiments of the present invention will be described in detail below with reference to the accompanying drawings. It should be noted that the embodiments and features of the embodiments in the present application may be arbitrarily combined with each other without conflict.
The steps illustrated in the flow charts of the figures may be performed in a computer system such as a set of computer-executable instructions. Also, while a logical order is shown in the flow diagrams, in some cases, the steps shown or described may be performed in an order different than here.
Example one
The embodiment provides an application program running method, as shown in fig. 1, the method is applied to an application program including a kernel initialization module, a kernel communication module and a service module, and the method includes an S11 communication channel establishing process and an S12 kernel communication process;
s11, the communication channel establishing process includes: loading a kernel initialization module, a kernel communication module and a service module according to a preset strategy;
s12, the kernel communication process comprises: and the kernel communication module receives the request of the service module, calls a kernel function to process the request and returns a processing result to the service module.
The embodiment of the invention provides an application program running method which supports communication between a plurality of service modules and a kernel.
The loading kernel initialization module is used for kernel initialization and kernel startup; the loading kernel communication module is used for providing a kernel unified communication interface and a registration interface for providing a kernel message callback function.
In an exemplary embodiment, the loading the kernel initialization module includes: and carrying out kernel initialization and kernel starting.
In an exemplary embodiment, the loading the kernel communication module includes: establishing a kernel communication interface and a registration interface; the kernel communication interface is used for the application program to actively communicate with the kernel; the registration interface is used for the kernel to actively communicate with the application program.
In an exemplary embodiment, the application program comprises a plurality of business modules; the loading of the kernel initialization module, the kernel communication module and the service module according to the preset strategy comprises the following steps:
loading the kernel communication module after the kernel initialization module is loaded successfully, and sequentially loading the service modules according to a preset sequence after the kernel communication modules are loaded successfully;
when the loading of the kernel initialization module or the kernel communication module fails, the application program quits the loading; and when the loading of the service module fails, loading the next service module according to the preset sequence.
In an exemplary embodiment, when the loading of the kernel initialization module or the kernel communication module fails, or the loading of the service module fails, a corresponding warning can be sent; the preset strategy further comprises: and selecting whether to add a corresponding service module according to the preset.
In an exemplary embodiment, the communication channel establishing process further includes: the kernel initialization module multiplexes codes in the service module; wherein the multiplexed code is implemented in the service module by a predefined macro.
The macro is predefined to distinguish multiplexing codes from non-multiplexing codes, and defines codes multiplexed to the service modules in Makefile.
The kernel of the application program contains a kernel initialization function; the kernel initialization module multiplexes the codes in the service module, and the multiplexing comprises the following steps: and the initialization function in the kernel multiplexes the codes in the service module.
In an exemplary embodiment, the kernel initialization module multiplexes code in the service module, including: the kernel initialization function in the kernel initialization module realizes parameter compilation by shielding functions except for the derived functions during compilation, and declares a scope as derived when the functions are derived.
In an exemplary embodiment, the kernel initialization module, the kernel communication module and the service module are stored in the form of a dynamically linked library.
In the embodiment of the invention, the method is applied to an application program comprising a kernel initialization module, a kernel communication module and a service module, and comprises a communication channel establishing process and a kernel communication process; the communication channel establishment procedure comprises: loading a kernel initialization module, a kernel communication module and a service module according to a preset strategy; the kernel communication process comprises the following steps: the kernel communication module receives the request of the service module, calls a kernel function to process the request and returns a processing result to the service module; the embodiment supports a plurality of service modules to communicate with the kernel. The service modules are independent from each other and do not influence each other, and if any one service module fails to be loaded, the loading of other service modules is not influenced. The system calls ensure kernel communication, the modular design ensures independent services, and the compiling and configuration ensure code multiplexing.
Example two
The present embodiment specifically describes the method of the above embodiment, and the description in the above embodiment of the method is also applicable to the present embodiment. The application program of the embodiment mainly includes the following features:
(1) modular design is adopted;
the application program comprises a kernel initialization module, a kernel communication module and a plurality of service modules;
as shown in fig. 2, the kernel communication technology mainly depends on a kernel initialization module and a kernel communication module, the two modules are loaded in order and preferentially in the loading process, and if any one module fails to be loaded, the program exits abnormally.
When the two modules are loaded successfully, a kernel communication channel is established, service modules such as the service module 1 and the service module 2 which need to communicate with the kernel are started according to a preset sequence, the normal operation of the program is not influenced when the loading of each service module fails, and the service modules can select whether to be loaded according to the configuration file of the application program.
1) The modular design of the application has the following characteristics: the functions of all modules of the application program are mutually independent, and all modules are sequentially loaded into the program space of the application program in a dynamic loading mode of a dynamic link library and finally embodied in the application program in a dynamic link library mode. Dynamic Link Library (DLL) is a way for microsoft corporation to implement the concept of shared function libraries in microsoft Windows operating system.
2) The kernel initialization module mainly completes two functions: initializing a kernel and starting the kernel;
kernel initialization: because the kernel needs some predefined configuration information when starting, the module has the main function of generating the information in the file system in the form of encrypted files so as to be convenient for initializing when starting the kernel.
Starting a kernel: and after the kernel initialization is completed, starting the kernel, and if the kernel fails to be started, the program is abnormally exited.
3) The kernel communication module mainly completes two functions: and providing a kernel unified communication interface and a registration interface of a kernel message callback function.
Unified kernel communication interface: in order to establish an interface for an application to actively communicate with the kernel. After the kernel initialization module is loaded successfully, the kernel is started, at the moment, the system call is registered in the system, at the moment, the kernel communication module can be loaded correctly, and whether the function instance is not found in the runtime can be prompted. And the kernel communication module calls the system call provided by the kernel and exposes a unified kernel communication interface outwards. So as to realize the function of the program actively communicating with the kernel.
Registration interface of kernel message callback function: in order to establish an interface for the kernel to actively communicate with the application. The kernel communication module is used as a bottom module, the interface of the kernel communication module is exposed outwards, and the kernel communication module should not call the function of other business modules. Thus, the processing of kernel messages is accomplished by callbacks. The service module registers the callback to the register function which exposes the callback to the outside. When the message of the kernel arrives, the kernel communication module selects a callback function and calls the callback function to realize the processing of the kernel message and establish an interface for the kernel to actively communicate with the application program.
And the service modules are sequentially started, a callback function of kernel information is registered to the kernel communication module after the service modules are started, and a kernel communication interface of the kernel communication module is called to realize communication with the kernel according to specific service requirements.
(2) The kernel initialization function provides the kernel with an encrypted configuration file, which is inevitably associated with the service, and needs to multiplex the code of the service module during the compilation process, and in this process, it is highly likely to multiplex a part of the code of the service module, which may call the kernel communication interface of the kernel communication module, which is actually a call to the system. It is the particularity of the system call that the system call cannot be used before the kernel starts, and is not allowed even if the participation in compilation is not called. Therefore, the codes multiplexed by these service modules must be distinguished by the participation of predefined macros, which are defined in Makefile. This is a core step of compilation. If the module is initialized to compile, the kernel communication interface is not called; and if the business module is compiled, calling the communication interface.
(3) In the code multiplexing problem mentioned in (2), the initialization module and the service module multiplex the same set of codes, which inevitably results in different functions of the homonymous function, and in the dynamic loading process of the dynamic link library, the homonymous function loaded later is replaced by the homonymous function loaded first, thereby causing code pollution of the homonymous function. For this purpose, the kernel initialization function needs to mask all functions except the derived function by a compiling parameter (-qvisibility) at the time of compiling, and indicates that its scope is derived when the function is declared, that is, (__ attribute (default))).
The kernel initialization function provides an encrypted configuration file for the kernel, and data in the file is encrypted kernel communication data; in the service module, the data are directly issued to the kernel through the kernel communication module, and the data required by the service module and the kernel initialization module at the same time are generated through the code multiplexed in the service module;
for example, a certain service needs to protect a certain file under the C disk, and the path of the file is the kernel communication data; for another example, a service may need to restrict access to an ip, which is the core communication data. The kernel initialization module needs to generate the data and then generates an encrypted file; the service module needs to produce the data and then sends the kernel. The code of the part for producing the transmitted data needs to be multiplexed.
For another example, the service of generating the encrypted file is not required to be initialized by the kernel, the encrypted file generated by the initialization of the kernel is not required, only kernel communication is required, and at this time, the kernel initialization module does not need to multiplex codes in the service module.
EXAMPLE III
The embodiment provides an application program architecture, and the description in the above method embodiment is also applicable to the embodiment, as shown in fig. 3, the application program includes a kernel initialization module 31, a kernel communication module 31, and a service module 31, where:
the kernel initialization module 31 is used for kernel initialization and kernel startup;
the kernel communication module 31 is used for establishing a kernel communication interface and a registration interface; the kernel communication interface is used for the application program to actively communicate with the kernel; the registration interface is used for the kernel to actively communicate with the application program.
In an exemplary embodiment, the kernel multiplexes code in the service module 31; wherein the multiplexed code is implemented in the service module 31 by a predefined macro.
In an exemplary embodiment, the kernel initialization module 31, the kernel communication module 31 and the service module 31 are stored in the form of a dynamic link library.
It will be understood by those of ordinary skill in the art that all or some of the steps of the methods, systems, functional modules/units in the devices disclosed above may be implemented as software, firmware, hardware, and suitable combinations thereof. In a hardware implementation, the division between functional modules/units mentioned in the above description does not necessarily correspond to the division of physical components; for example, one physical component may have multiple functions, or one function or step may be performed by several physical components in cooperation. Some or all of the components may be implemented as software executed by a processor, such as a digital signal processor or microprocessor, or as hardware, or as an integrated circuit, such as an application specific integrated circuit. Such software may be distributed on computer readable media, which may include computer storage media (or non-transitory media) and communication media (or transitory media). The term computer storage media includes volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data, as is well known to those of ordinary skill in the art. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, Digital Versatile Disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can accessed by a computer. In addition, communication media typically embodies computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media as known to those skilled in the art.
Claims (9)
1. An application program running method is applied to an application program comprising a kernel initialization module, a kernel communication module and a service module, and comprises a communication channel establishing process and a kernel communication process:
the communication channel establishment procedure comprises: loading a kernel initialization module, a kernel communication module and a service module according to a preset strategy;
the kernel communication process comprises the following steps: the kernel communication module receives the request of the service module, calls a kernel function to process the request and returns the processing result to the service module,
the application program comprises a plurality of business modules; the loading of the kernel initialization module, the kernel communication module and the service module according to the preset strategy comprises the following steps:
loading the kernel communication module after the kernel initialization module is loaded successfully, and sequentially loading the service modules according to a preset sequence after the kernel communication modules are loaded successfully;
when the loading of the kernel initialization module or the kernel communication module fails, the application program quits the loading; and when the loading of the service module fails, loading the next service module according to the preset sequence.
2. The method of claim 1, wherein loading the kernel initialization module comprises: and carrying out kernel initialization and kernel starting.
3. The method of claim 1, wherein loading the kernel communication module comprises: establishing a kernel communication interface and a registration interface; the kernel communication interface is used for the application program to actively communicate with the kernel; the registration interface is used for the kernel to actively communicate with the application program.
4. The method of claim 1, wherein the communication channel establishment procedure further comprises: the kernel initialization module multiplexes codes in the service module; wherein the multiplexed code is implemented in the service module by a predefined macro.
5. The method of claim 4, wherein the kernel initialization module multiplexes code in the service module, comprising: the kernel initialization function in the kernel initialization module realizes parameter compilation by shielding functions except for the derived functions during compilation, and declares a scope as derived when the functions are derived.
6. The method according to any of claims 1-5, wherein the kernel initialization module, kernel communication module and service module are stored in the form of a dynamically linked library.
7. An application architecture, comprising a kernel initialization module, a kernel communication module, and a service module, wherein:
the kernel initialization module is used for kernel initialization and kernel startup;
the kernel communication module is used for establishing a kernel communication interface and a registration interface; the kernel communication interface is used for the application program to actively communicate with the kernel; the registration interface is used for the kernel to actively communicate with the application program,
the application program comprises a plurality of business modules;
loading a kernel initialization module, a kernel communication module and a service module according to a preset strategy, wherein the loading comprises the following steps:
loading the kernel communication module after the kernel initialization module is loaded successfully, and sequentially loading the service modules according to a preset sequence after the kernel communication modules are loaded successfully;
when the loading of the kernel initialization module or the kernel communication module fails, the application program quits the loading; and when the loading of the service module fails, loading the next service module according to the preset sequence.
8. The application program architecture of claim 7, wherein the kernel initialization module multiplexes code in the business module; wherein the multiplexed code is implemented in the service module by a predefined macro.
9. The application program architecture according to claim 7, characterized in that said kernel initialization module, kernel communication module and service module are stored in the form of dynamically linked libraries.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910278412.4A CN109976820B (en) | 2019-04-09 | 2019-04-09 | Application program running method and application program framework |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910278412.4A CN109976820B (en) | 2019-04-09 | 2019-04-09 | Application program running method and application program framework |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109976820A CN109976820A (en) | 2019-07-05 |
| CN109976820B true CN109976820B (en) | 2020-03-03 |
Family
ID=67083597
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910278412.4A Active CN109976820B (en) | 2019-04-09 | 2019-04-09 | Application program running method and application program framework |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109976820B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111984342B (en) * | 2020-09-03 | 2023-04-07 | 科大讯飞股份有限公司 | Method and related device for loading dynamic link library |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102567006A (en) * | 2010-12-31 | 2012-07-11 | 中国移动通信集团黑龙江有限公司 | Application service expanding method, device and system |
| CN106972963A (en) * | 2017-03-23 | 2017-07-21 | 数据通信科学技术研究所 | Enabling for business module enables control method after control method, collapse are restarted |
| CN109543400A (en) * | 2017-09-21 | 2019-03-29 | 华为技术有限公司 | A kind of method and apparatus of dynamic management core nodes |
Family Cites Families (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102681885A (en) * | 2011-03-18 | 2012-09-19 | 新奥特（北京）视频技术有限公司 | Media asset management system capable of separating operations |
| CN103729288B (en) * | 2013-11-01 | 2016-02-24 | 华中科技大学 | The adjustment method of application program under a kind of embedded multi-core environment |
| CN104375857B (en) * | 2014-10-22 | 2016-06-01 | 腾讯科技（深圳）有限公司 | A kind of application program runs the method for Multi-instance, device and terminating unit |
| US10127091B1 (en) * | 2016-12-22 | 2018-11-13 | Juniper Networks, Inc. | Intercepting socket metadata |
| CN108491278B (en) * | 2018-03-13 | 2020-09-18 | 网宿科技股份有限公司 | Method and network device for processing service data |
-
2019
- 2019-04-09 CN CN201910278412.4A patent/CN109976820B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102567006A (en) * | 2010-12-31 | 2012-07-11 | 中国移动通信集团黑龙江有限公司 | Application service expanding method, device and system |
| CN106972963A (en) * | 2017-03-23 | 2017-07-21 | 数据通信科学技术研究所 | Enabling for business module enables control method after control method, collapse are restarted |
| CN109543400A (en) * | 2017-09-21 | 2019-03-29 | 华为技术有限公司 | A kind of method and apparatus of dynamic management core nodes |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109976820A (en) | 2019-07-05 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| WO2021196597A1 (en) | Service plug-in loading implementation method and apparatus, and terminal device | |
| CN114077462B (en) | Method, device, equipment and medium for software operating system to call Android HIDL interface | |
| CN108121594B (en) | Process management method and device | |
| CN109491725B (en) | Interactive multi-opening method and system of application program, storage medium and electronic equipment | |
| EP2557498A1 (en) | Updating method and computer system for hypervisor components | |
| US11915067B2 (en) | Resource management method for node in kubernetes, device, and medium | |
| US20120198431A1 (en) | Method for upgrading hypervisor component and computer system | |
| CN110780871B (en) | A negative one screen loading method, device, terminal and computer readable storage medium | |
| CN107273126B (en) | Application development method and device | |
| CN113360893B (en) | Container-based intelligent contract execution method and device and storage medium | |
| CN111736913B (en) | Class loading method and device | |
| CN114077460A (en) | Method, equipment and medium for calling Android dynamic library HAL interface by software operating system | |
| KR20230069088A (en) | Container cluster management method and its system | |
| CN112752258B (en) | eSIM card opening method, mobile phone terminal and service acceptance system | |
| CN109976820B (en) | Application program running method and application program framework | |
| US20230061228A1 (en) | Managing shared applications at the edge of a content delivery network | |
| CN113938527B (en) | Extension processing method of API gateway, computing device and storage medium | |
| CN115604344B (en) | Micro-service current limiting method and device | |
| CN114416219B (en) | System function calling method, device, electronic equipment and readable medium | |
| CN111026452B (en) | Method and system for remote 32-bit process injection of 64-bit process | |
| CN113055465A (en) | Micro-service dynamic updating method supporting transaction consistency | |
| CN111694730B (en) | Method and device for eliminating error reference control resource | |
| CN112948021B (en) | Android mobile terminal development method for configuratively accessing SDK of the same type | |
| CN112905194B (en) | Installation package generation method and device | |
| CN111897554A (en) | Upgrading method, device and system |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |