CN108345496B

CN108345496B - Method and device for running application program

Info

Publication number: CN108345496B
Application number: CN201710058876.5A
Authority: CN
Inventors: 麻先盛; 代雷
Original assignee: Huawei Technologies Co Ltd
Current assignee: Huawei Technologies Co Ltd
Priority date: 2017-01-23
Filing date: 2017-01-23
Publication date: 2020-12-15
Anticipated expiration: 2037-01-23
Also published as: CN108345496A

Abstract

The embodiment of the invention provides a method and a device for running an application program, relates to the field of computers, and can realize that all resources required by running a multi-process application program are maintained by the application program at a sandbox level. The method comprises the following steps: acquiring a configuration file of an application program to be operated; according to the configuration file, a first process virtual machine is created, first program codes (a process management unit which is realized based on an exokernel operating system and used for maintaining data of an application program interacted with at least two functional units of the application program) are loaded and run in the first process virtual machine so as to form a sandbox in the operating system, and the first process virtual machine running the first program codes runs in the sandbox; according to the configuration file, at least two second process virtual machines are created in the sandbox, and a second program code (a functional unit of the application program realized based on the exokernel operating system) is loaded and executed in each second process virtual machine so as to run the application program in the sandbox.

Description

Method and device for running application program

Technical Field

The present invention relates to the field of computers, and in particular, to a method and an apparatus for running an application.

Background

In a conventional software System, all resources required by a terminal device to run an application are maintained by an Operating System (OS) of the terminal device, and the terminal device can access the resources through System calls when running the application. When these resources are maintained by an application, the linked-together runtime library that supports the application running, which may provide operating system-like functionality, may be referred to as a kernel operating system (LibOS).

In the current LibOS project, Graphene LibOS can support multi-process applications. In the multi-process application, one process running in one OS process of the terminal device may be referred to as one micro-process, that is, the multi-process application includes a plurality of micro-processes running in a plurality of OS processes of the terminal device. Typically, each micro-process is started by a background process in the OS of the terminal device, and a plurality of micro-processes are started to run in a Sandbox (Sandbox) of the OS process of the terminal device, and the state information and resource management of each micro-process in the Sandbox are maintained by the OS of the terminal device.

However, when the multi-process application supported by the Graphene LibOS runs in the sandbox, since the state information and resource management of each micro-process in the sandbox are maintained by the OS of the terminal device, that is, the state information and resource management of each micro-process in the sandbox cannot be maintained by the application, the Graphene LibOS cannot achieve that all resources required for running the multi-process application are maintained by the application at the sandbox level.

Disclosure of Invention

The application provides a method and a device for running an application program, which can realize that all resources required by running the multi-process application program are maintained by the application program at a sandbox level.

In order to achieve the purpose, the technical scheme is as follows:

in a first aspect, a method for running an application is provided, and the method may include: acquiring a configuration file of an application program to be run, wherein the configuration file is used for indicating resources required by creating a process virtual machine (including a first process virtual machine and a second process virtual machine), then creating the first process virtual machine according to the configuration file, loading and running a first program code (namely, a process management unit which is implemented based on an outer core operating system and used for maintaining data of the application program interacted between at least two functional units of the application program) in the first process virtual machine to form a sandbox in the operating system, running the first process virtual machine with the first program code in the sandbox, and creating at least two second process virtual machines in the sandbox according to the configuration file, and loading and running a second program code (namely, a functional unit of the application program which is implemented based on the outer core operating system) in each second process virtual machine of the at least two second process virtual machines, to run the application in the sandbox.

In the method for running the application program provided by the application program, on one hand, because the first program code is a process management unit implemented based on an outer core operating system, and the first program code runs in the first process virtual machine, and the outer core operating system can implement that resources required for running the application program are all maintained by the application program itself, when the process management unit implemented based on the outer core operating system in the embodiment of the present invention, the resources required for running the process management unit in the first process virtual machine can be maintained by the process management unit, that is, the resources required for running the process management unit do not need to be maintained by the operating system. On the other hand, since the second program code is a functional unit of an application program implemented based on the exo-core operating system, and a second program code runs in a second process virtual machine, and the exo-core operating system can implement that resources required for running the application program are all maintained by the application program itself, when each functional unit of the application program is implemented based on the exo-core operating system in the embodiment of the present invention, the resources required for running one functional unit of the application program in each second process virtual machine can be maintained by the functional unit of the application program, that is, the resources required for running each functional unit of the application program do not need to be maintained by the operating system. Moreover, because the process management unit and the at least two functional units of the application program are both operated in the sandbox, and the process management unit is used for maintaining the data of the application program interacted between the at least two functional units, the data of the application program interacted between the at least two functional units of the application program in the sandbox does not need to be maintained by the operating system. Therefore, the method for running the application program can realize that all resources required by running the multi-process application program are maintained by the application program at the sandbox level.

Further, due to the method for running the application provided in the present application, all resources required for running the multi-process application can be maintained by the application at a sandbox level, and therefore, when the application is migrated from one device (for example, a device currently running the application) to another device (for example, a target device), all data in the sandbox running in the operating system of the device currently running the application can be migrated to the sandbox running in the operating system of the target device, so that services provided by the application (for example, services provided by the application to a user using the application) can be uninterrupted.

In a first possible implementation manner of the first aspect, the method for running the application program provided by the present application may further include: and determining target equipment to be migrated of the application program, and migrating the application program from the equipment currently running the application program to the target equipment.

In the method for running the application program, because the target device to which the application program is to be migrated may be determined, and the application program is migrated from the device currently running the application program to the target device, when the memory of the device currently running the application program is insufficient (that is, the remaining memory of the device currently running the application program is insufficient to run the application program), the application program may be migrated from the device currently running the application program to the target device having a relatively sufficient memory (that is, the remaining memory of the target device is sufficient to run the application program), so as to ensure normal running of the application program.

In a second possible implementation manner of the first aspect, the method for migrating the application program from a device currently running the application program to a target device may include: copying the configuration file of the application program, a first program code (namely, a process management unit which is realized based on an outer core operating system and is used for managing at least two functional units of the application program) and at least two second program codes (namely, a functional unit of the application program which is realized based on the outer core operating system) from a device which currently runs the application program to a target device; and then running the application program on the target device, wherein the method for running the application program on the target device is the same as the method for running the application program on the source device.

In the application, since the method for running the application on the target device is the same as the method for running the application on the device currently running the application, when the application is run on the target device by using the method for running the application provided by the application, all resources required for running the multi-process application can be maintained by the application at the sandbox level.

In a second possible implementation manner of the first aspect, the method for running the application program provided by the present application may further include: synchronizing data of a process management unit in a first process virtual machine on equipment currently running the application program to the first process virtual machine on target equipment; executing the following steps for each of at least two second process virtual machines on the equipment currently running the application program: and synchronizing the data of the application program in one second process virtual machine of at least two second process virtual machines on the equipment which currently runs the application program to the one second process virtual machine on the target equipment.

According to the method for running the application program, all resources required for running the multi-process application program can be maintained by the application program at a sandbox level, and data of a process management unit in a first process virtual machine on equipment currently running the application program can be synchronized to the first process virtual machine on target equipment; and for each of at least two second process virtual machines on the device currently running the application program, performing the following steps: and synchronizing the data of the application program in one of at least two second process virtual machines on the device currently running the application program to the one second process virtual machine on the target device, so that all data in the sandbox running in the operating system of the device currently running the application program can be migrated to the sandbox running in the operating system of the target device. At this time, if the application program running in the operating system of the device currently running the application program is interrupted again, the service provided by the application program to the user using the application program can not be interrupted when the device currently running the application program migrates the application program from the device currently running the application program to the target device.

In a second aspect, there is provided an apparatus for running an application, the apparatus may include: the device comprises an acquisition module and an operation module. The acquisition module is used for acquiring a configuration file of an application program to be run, wherein the configuration file is used for indicating resources required by creating process virtual machines (including a first process virtual machine and at least two second process virtual machines); the running module is used for creating a first process virtual machine according to the configuration file acquired by the acquisition module, and loading and running a first program code (namely, a process management unit which is realized based on an exokernel operating system and used for maintaining data of the application program interacted between at least two functional units of the application program) in the first process virtual machine so as to form a sandbox in the operating system, wherein the first process virtual machine running the first program code runs in the sandbox; the running module is further configured to create at least two second process virtual machines in the sandbox according to the configuration file acquired by the acquiring module, and load and run a second program code (i.e., a functional unit of the application program implemented based on the exokernel operating system) in each of the at least two second process virtual machines, so as to run the application program in the sandbox.

In a first possible implementation manner of the second aspect, the apparatus may further include: a determination module and a migration module. The determining module is used for determining the target equipment to be migrated of the application program operated by the operating module; the migration module is used for migrating the application program from the device which runs the application program to the target device determined by the determination module.

In a second possible implementation manner of the second aspect, the migration module is specifically configured to copy, from a device currently running the application program to the target device determined by the determination module, at least two second program codes (i.e., one functional unit of the application program implemented based on the exokernel operating system) from the configuration file of the application program acquired by the acquisition module, the first program code loaded and run by the running module, and (i.e., a process management unit implemented based on the exokernel operating system and used for managing at least two functional units of the application program), so that the target device runs the application program on the target device, where a method for the migration module to run the application program on the target device is the same as a method for the apparatus to run the application program on the device currently running the application program.

In a third possible implementation manner of the second aspect, the apparatus may further include a synchronization module. The synchronization module is used for synchronizing data of a process management unit in a first process virtual machine created by an operation module on the equipment currently running the application program to the first process virtual machine on the target equipment; for each of at least two second process virtual machines on the device currently running the application program: the synchronization module is further configured to synchronize data of the application program in one of the at least two second process virtual machines created by the running module on the device currently running the application program to the one second process virtual machine on the target device.

For a description of the technical effect of the second aspect or any one of its possible implementations, reference may be specifically made to the above-mentioned description of the technical effect of the first aspect or any one of its possible implementations, and details are not described here again.

In a third aspect, an apparatus for running an application is provided and may include a processor and a memory. The memory is used for storing computer-executable instructions, and when the apparatus for running the application program runs, the processor executes the computer-executable instructions stored in the memory, so that the apparatus for running the application program performs the method for running the application program described in the first aspect or the optional implementation manner thereof.

In a fourth aspect, a computer-readable storage medium is provided, in which one or more programs are stored, the one or more programs including computer-executable instructions, and when the processor of the apparatus for running an application executes the instructions, the apparatus for running an application performs the method for running an application according to the first aspect or the optional implementation manner of the first aspect.

For the description of the technical effects of the third aspect and the fourth aspect, reference may be specifically made to the description of the technical effects of the first aspect or any one of possible implementation manners thereof, and details are not described herein again.

In a fifth aspect, an apparatus is provided, where an operating system of the apparatus runs a sandbox, and the sandbox runs a first process virtual machine and at least two second process virtual machines; the first process virtual machine is used for loading and running a first program code (namely, a process management unit which is implemented based on an exokernel operating system and is used for maintaining data of the application program interacted between at least two functional units of the application program); each of the at least two second process virtual machines is configured to load and run a second program code (i.e., a functional unit of the application program implemented based on the exokernel operating system).

For a description of the technical effect of the fifth aspect, reference may be made to the above description of the technical effect of the first aspect, and details are not repeated here.

Drawings

Fig. 1 is a schematic hardware structure diagram of a computer according to an embodiment of the present invention;

fig. 2 is a schematic structural diagram of an operating system of a terminal device according to an embodiment of the present invention;

fig. 3 is a first schematic diagram illustrating a method for running an application according to an embodiment of the present invention;

fig. 4 is a schematic diagram illustrating a method for running an application according to an embodiment of the present invention;

fig. 5 is a schematic diagram of a method for running an application according to an embodiment of the present invention;

fig. 6 is a fourth schematic diagram illustrating a method for running an application according to an embodiment of the present invention;

fig. 7 is a first schematic structural diagram of an apparatus for running an application according to an embodiment of the present invention;

fig. 8 is a schematic structural diagram of an apparatus for running an application according to an embodiment of the present invention;

fig. 9 is a schematic structural diagram three of an apparatus for running an application according to an embodiment of the present invention.

Detailed Description

In the embodiments of the present invention, words such as "exemplary" or "for example" are used to mean serving as examples, illustrations or descriptions. Any embodiment or design described as "exemplary" or "e.g.," an embodiment of the present invention is not necessarily to be construed as preferred or advantageous over other embodiments or designs. Rather, use of the word "exemplary" or "such as" is intended to present concepts related in a concrete fashion.

The terms "first" and "second", etc. in the embodiments of the present invention are used to distinguish different objects, not to describe a specific order. For example, the first process virtual machine and the second process virtual machine are used to distinguish between different process virtual machines, rather than to describe a particular order of process virtual machines.

In the description of the present invention, the meaning of "a plurality" means two or more unless otherwise specified. For example, the plurality of terminal devices means two or more terminal devices.

Generally, in the current LibOS project, graphics LibOS can support multi-process applications. The multi-process application includes a plurality of micro-processes running in a plurality of OS processes of the terminal device. Each micro-process is started through a background process in the OS of the terminal equipment, a plurality of micro-processes can run in a sandbox of the OS process of the terminal equipment after being started, and state information and resource management of each micro-process in the sandbox are maintained by the OS of the terminal equipment. However, when the multi-process application supported by the Graphene LibOS runs in the sandbox, since the state information and resource management of each micro-process in the sandbox are maintained by the OS of the terminal device, that is, the state information and resource management of each micro-process in the sandbox cannot be maintained by the application, the Graphene LibOS cannot achieve that all resources required for running the multi-process application are maintained by the application at the sandbox level.

In order to solve the above problem, embodiments of the present invention provide a method and an apparatus for running an application, which can implement that all resources required for running a multi-process application are maintained by the application at a sandbox level.

Specifically, the method and the apparatus for running an application according to the embodiment of the present invention will be described in detail in the following embodiments.

The embodiment of the invention provides a method and a device for running an application program, and the method and the device can be applied to equipment. The device may be a terminal device or other device. For example, in the following description of the embodiment of the present invention, a device currently running the application may be a terminal device. In the process of migrating the application program, the device to be migrated by the application program may be a target device. Specifically, in the process of migrating the application program from the device currently running the application program to the target device, the device currently running the application program may also be referred to as a source terminal device, and the device to be migrated of the application program may also be referred to as a target terminal device.

Optionally, the terminal device may be an intelligent terminal device with an operating system. Illustratively, the intelligent terminal device may be: the smart terminal device may be a computer, a smart phone, a server, a tablet computer, a notebook computer, a netbook, a Personal Digital Assistant (PDA), a smart watch, a smart bracelet, or the smart terminal device may be other types of smart terminal devices.

The intelligent terminal devices all have independent operating systems, for example, the intelligent terminal devices may have an Android operating system, an iOS operating system, a Windows operating system, a Unix operating system, a Linux operating system, a Mac operating system, or other operating systems, which is not limited in the embodiments of the present invention.

The terminal device provided by the embodiment of the present invention is taken as a computer for illustration. The respective constituent elements of the computer will be specifically described below with reference to fig. 1. As shown in fig. 1, the computer includes: a processor 01, a memory 02, an input unit 03, an output unit 04, and the like. Those skilled in the art will appreciate that the configuration of the computer shown in FIG. 1 does not constitute a limitation of the computer, and may include more or less than the components shown in FIG. 1, or may combine some of the components shown in FIG. 1, or may be arranged differently than the components shown in FIG. 1.

The processor 01 is a control center of the computer, connects various parts of the entire computer using various interfaces and lines, performs various functions of the computer and processes data by operating or executing software programs and/or modules stored in the memory 02 and calling data stored in the memory 02, thereby monitoring the computer as a whole. The processor 01 may be a Central Processing Unit (CPU). The processor 01 may also be other general-purpose processors, Digital Signal Processors (DSPs), Application Specific Integrated Circuits (ASICs), field-programmable gate arrays (FPGAs) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, and the like. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like.

The memory 02 may be used to store software programs and modules, and the processor 01 executes various functional applications and data processing of the computer by operating the software programs and modules stored in the memory 02. The memory 02 may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program required by at least one function (such as a sound playing function, an image playing function, etc.), and the like; the storage data area may store data (such as audio data, image data, etc.) created according to the use of the computer. Further, the memory 02 may include a volatile memory (volatile memory), such as a random-access memory (RAM); the memory 02 may also include a non-volatile memory (non-volatile memory), such as a read-only memory (ROM), a flash memory (flash memory), a Hard Disk Drive (HDD) or a solid-state drive (SSD); the memory 32 may also comprise a combination of memories of the kind described above.

The input unit 03 can be used for receiving input numeric or character information, and the input unit can include input devices such as a keyboard, a mouse, a touch pad, a trackball, a digitizer tablet, a stylus/pointer, a touch screen, a game controller, a game joystick, a microphone, a scanner, a barcode reader, and a network camera.

The output unit 04 may include output devices such as a printer, a speaker, and a display.

The computer shown in fig. 1 may further include a bus, a display card, various sensors, and the like, which are not described in detail herein.

It should be noted that, taking a device as a terminal device as an example, an application program executed by the method and apparatus for executing an application program provided in the embodiment of the present invention may be a multi-process application program installed on the terminal device. Typically a multi-process application comprises at least two functional units to implement at least two functions of the multi-process application (wherein each functional unit implements one function of the multi-process application). For example, the application program in the embodiment of the present invention may be a mailbox installed on the terminal device, and the function of sending an email in the mailbox and the function of receiving an email in the mailbox may be two functional units of the application program.

The operating system of the terminal device provided by the embodiment of the invention runs a sandbox, and the sandbox runs a first process virtual machine and at least two second process virtual machines. The first process virtual machine is used for loading and running a first program code, and the first program code is a process management unit realized based on an outer core operating system; each second process virtual machine is used for loading and running a second program code, and the second program code is a functional unit of an application program realized based on the exokernel operating system. Wherein the process management unit may be configured to maintain data of the application program interacted between at least two functional units of the application program. For example, the operating system of the terminal device shown in fig. 2 is described by taking an example in which the application program includes four functional units. As shown in fig. 2, a sandbox runs in an operating system of a terminal device according to an embodiment of the present invention, the sandbox runs in one first process virtual machine and four second process virtual machines, the first process virtual machine runs in a process management unit (a first program code) implemented based on an exokernel operating system, and each second process virtual machine runs in one functional unit (a second program code) of an application implemented based on the exokernel operating system. In fig. 2, in order to distinguish the four functional units of the application program implemented based on the exo-core operating system, which run in the four second process virtual machines, the four functional units are respectively represented as functional unit 1, functional unit 2, functional unit 3, and functional unit 4.

As shown in fig. 2, a communication channel may be further included in the sandbox, and the communication channel may be used to transmit data of the application program interacted among the four functional units of the application program; for example, the communication channel may be used to transmit data of the application program that is interacted between the functional unit 1 and the functional unit 2.

Since fig. 2 illustrates that the application includes four functional units, four second process virtual machines are created in the sandbox shown in fig. 2 to load and run the program codes of the four functional units of the application.

For example, the process management unit in fig. 2 may be a functional unit implementing a monitor (monitor) function, and the process management unit may be configured to maintain data of an application program interacted among four functional units of the application program.

In the embodiment of the present invention, the process management unit implemented based on the exo-core operating system may be understood as that the first program code implementing the process management unit is implemented based on the system architecture programming of the exo-core operating system. Accordingly, in the embodiment of the present invention, a functional unit of an application implemented based on an exo-core operating system may be understood as a first program code that implements the functional unit of the application implemented by programming a system architecture based on the exo-core operating system.

A process is running program code. In the embodiment of the present invention, the first program code may be referred to as a first process when running, and may be referred to as a second process when running.

The execution main body of the method for running the application program provided by the embodiment of the invention can be a device for running the application program. For example, the apparatus for running the application may be a device (for example, the terminal device or other devices described above), an operating system of the device, or a functional module integrated in the device for running the application. The following takes an execution main device of the method for running the application program as an example, and exemplarily describes the method for running the application program provided by the embodiment of the present invention.

As shown in fig. 3, an embodiment of the present invention provides a method for running an application program, where the method includes:

s101, the terminal equipment obtains a configuration file of an application program to be operated.

In the embodiment of the present invention, when a user (e.g., a system administrator) using a terminal device needs to run an application program in the terminal device, the terminal device may be triggered to run the application program through an input operation (e.g., double-clicking an icon of the application program) on the terminal device, and when the terminal device receives the input operation of the user, the terminal device may execute S101, that is, the terminal device may obtain a configuration file of the application program to be run, so as to run the application program according to the configuration file.

Wherein the configuration file may be used to indicate resources required to create the process virtual machine. The process virtual machine may include a first process virtual machine and at least two second process virtual machines.

Optionally, in this embodiment of the present invention, the resource required for creating the process virtual machine may include a memory required for creating the process virtual machine, a driver used for creating the process virtual machine, and the like.

Alternatively, the configuration file may be stored in a hard disk of the terminal device. Specifically, the terminal device may obtain the configuration file from a hard disk of the terminal device.

And S102, the terminal equipment creates a first process virtual machine according to the configuration file.

In the embodiment of the present invention, the configuration file may indicate resources required for creating the first process virtual machine (for example, a memory required for creating the first process virtual machine and a driver used for creating the first process virtual machine). Optionally, the terminal device may create the first process virtual machine according to the configuration file, for example, the terminal device may create the first process virtual machine according to the memory and the driver indicated in the configuration file.

S103, the terminal device loads and runs the first program code in the first process virtual machine so as to form a sandbox in an operating system of the terminal device.

The first program code is a process management unit realized based on an outer core operating system, and a first process virtual machine running with the first program code runs in a sandbox.

It should be noted that, in the embodiment of the present invention, the process management unit implemented based on the exo-core operating system may be understood that the first program code for implementing the process management unit is implemented by programming a system architecture based on the exo-core operating system. Since the first process virtual machine runs in the sandbox and the process management unit implemented based on the exokernel operating system runs in the first process virtual machine, it can be understood that the process management unit runs in the sandbox.

In an embodiment of the present invention, the process management unit may be a functional unit that implements a monitor function.

Alternatively, the first program code may be saved in the hard disk of the terminal device in the form of an image file or a system snapshot.

The method for the terminal device to load and run the first program code in the first process virtual machine may be: the terminal equipment loads a first program code saved in the form of an image file or a system snapshot from a hard disk of the terminal equipment into the first process virtual machine, and then the terminal equipment runs the first program code in the first process virtual machine.

A sandbox is a virtual system program, which is an operating environment that restricts program behavior according to security policies. The sandbox in the embodiment of the present invention may provide an isolated environment, so that the application program or the process virtual machine, etc. running in the sandbox are not affected by other sandboxes (specifically, may be unaffected by the application program or the process virtual machine, etc. running in other sandboxes). For example, the sandbox may provide an isolated environment for the first process virtual machine and the at least two second process virtual machines running in the sandbox such that the first process virtual machine and the at least two second process virtual machines may be unaffected by the process virtual machines running in other sandboxs.

And S104, the terminal device creates at least two second process virtual machines in the sandbox according to the configuration file.

In this embodiment of the present invention, the configuration file may further indicate resources required for creating each of the at least two second process virtual machines (for example, a memory required for creating each second process virtual machine, a driver adopted for creating each second process virtual machine, and the like). The method for the terminal device to create each second process virtual machine according to the configuration file is similar to the method for the terminal device to create the first process virtual machine according to the configuration file in the foregoing embodiment, and reference may be specifically made to the method for the terminal device to create the first process virtual machine according to the configuration file in the foregoing embodiment, which is not described herein again.

S105, the terminal device loads and runs a second program code in each of the at least two second process virtual machines so as to run the application program in the sandbox.

Wherein the second program code is a functional unit of the application program implemented based on the exokernel operating system.

For example, assuming that the application is a mailbox installed on the terminal device, the function of sending a mail from the mailbox and the function of receiving a mail from the mailbox may be two functional units of the application.

Since the application program in the embodiment of the present invention is a multi-process application program, in the embodiment of the present invention, the application program may include at least two functional units, and thus, the terminal device needs to create at least two second process virtual machines to load and run the program codes that implement the at least two functional units of the application program, that is, the second program codes.

In the embodiment of the present invention, since a second program code may be referred to as a second process when running, and the second program code is a functional unit of the application program implemented based on the exokernel operating system, the second process may implement the functional unit.

In this embodiment of the present invention, the process management unit may be configured to maintain data of an application program interacted between at least two functional units of the application program, and specifically, the data of the application program interacted between the at least two functional units may be state information between at least two second processes implementing the at least two functional units (for example, may be a relationship between the at least two second processes) and resource management information between the at least two second processes (for example, may be information for managing a name of each second process of the at least two second processes). Wherein, the relationship between the at least two second processes may be understood as: the at least two second processes are in the relationship between a parent process and a child process; specifically, for example, if a second process (which may be referred to as process a) is created by another second process (which may be referred to as process b), then the relationship between process a and process b is the parent process and the child process, i.e., process b may be referred to as the parent process and process a may be referred to as the child process.

To this end, the terminal device may run the application in the terminal device.

In the method for running an application program provided in the embodiment of the present invention, on one hand, because the first program code is a process management unit implemented based on an outer core operating system, and the first program code runs in the first process virtual machine, and the outer core operating system can implement that resources required for running the application program are all maintained by the application program itself, when the process management unit implemented based on the outer core operating system in the embodiment of the present invention, the resources required for running the process management unit in the first process virtual machine can be maintained by the process management unit, that is, the resources required for running the process management unit do not need to be maintained by the operating system of the terminal device. On the other hand, since the second program code is a functional unit of an application program implemented based on the exo-core operating system, and a second program code runs in a second process virtual machine, and the exo-core operating system can implement that resources required for running the application program are all maintained by the application program itself, when each functional unit of the application program is implemented based on the exo-core operating system in the embodiment of the present invention, the resources required for running one functional unit of the application program in each second process virtual machine can be maintained by the functional unit of the application program, that is, the resources required for running each functional unit of the application program do not need to be maintained by the operating system of the terminal device. Moreover, because the process management unit and the at least two functional units of the application program are both operated in the sandbox, and the process management unit is used for maintaining the data of the application program interacted between the at least two functional units, the data of the application program interacted between the at least two functional units of the application program in the sandbox does not need to be maintained by the operating system of the terminal device. Therefore, the method for running the application program provided by the embodiment of the invention can realize that all resources required for running the multi-process application program are maintained by the application program at the sandbox level.

Further, according to the method for running the application provided by the present application, all resources required for running the multi-process application can be maintained by the application at a sandbox level, and therefore, when the application is migrated from one terminal device (e.g., a source terminal device) to another terminal device (e.g., a target terminal device), all data in the sandbox running in the operating system of the source terminal device can be migrated to the sandbox running in the operating system of the target terminal device, so that services provided by the application (e.g., services provided by the application for a user using the application) can be uninterrupted.

In this embodiment of the present invention, the terminal device (i.e., the device currently running the application) described in S101 to S105 may be a terminal device in a terminal device cluster formed by a plurality of terminal devices, and when the memory of the terminal device is insufficient (i.e., the remaining memory of the terminal device is insufficient to run the application), the terminal device may migrate the application running on the terminal device to another terminal device (i.e., the target device) in the terminal device cluster, where the memory of the terminal device is sufficient (i.e., the remaining memory of the terminal device is sufficient to run the application), except the terminal device. When the terminal device migrates the application program running on the terminal device to other terminal devices in the terminal device cluster, which have sufficient memory except the terminal device, the terminal device may be referred to as a source terminal device, and the other terminal devices, which have sufficient memory to be migrated, of the application program may be referred to as target terminal devices. When the above-described S101-S105 performed by the terminal device shown in fig. 3 is performed by the source terminal device, it may be represented as S101'-S105' shown in fig. 4.

S101', the source terminal equipment obtains a configuration file of an application program to be operated.

S102', the source terminal device creates a first process virtual machine according to the configuration file.

S103', the source terminal device loads and runs the first program code in the first process virtual machine so as to form a sandbox in the operating system of the source terminal device.

S104', the source terminal device creates at least two second process virtual machines in the sandbox according to the configuration file.

S105', the source terminal device loads and runs a second program code in each of the at least two second process virtual machines, so as to run the application program in the sandbox.

It should be noted that, because the method for the source terminal device to run the application program shown in S101'-S105' is the same as the method for the terminal device to run the application program shown in S101-S105, for the description of S101'-S105', reference may be specifically made to the description of S101-S105, and details are not repeated here.

Optionally, as shown in fig. 4, after S105', the method for running an application according to the embodiment of the present invention may further include the following S106 and S107:

and S106, the source terminal equipment determines the target terminal equipment to be migrated of the application program.

Optionally, the source terminal device may determine the target terminal device in the terminal device cluster. The method for determining the target terminal device in the terminal device cluster by the source terminal device may be one of the following three possible implementation manners.

The first possible implementation is: the system administrator determines the target terminal device in the terminal device cluster and informs the source terminal device which terminal device in the terminal device cluster the target terminal device is. The method specifically comprises the following steps: the system administrator can obtain the memory use information of each terminal device in the terminal device cluster, so that one terminal device with sufficient memory is selected as a target terminal device in the terminal device cluster according to the memory use information of each terminal device in the terminal device cluster, and then the system administrator can inform a source terminal device of the IP address of the target terminal device to which the application program is to be migrated by operating management software or inputting a command in a command line window of the terminal device, so that the source terminal device can determine the target terminal device to which the application program is to be migrated as the terminal device in the terminal device cluster according to the IP address of the target terminal device.

A second possible implementation is: and the source terminal equipment determines the target terminal equipment in the terminal equipment cluster. The method specifically comprises the following steps: the source terminal device may send a first request message to other terminal devices (hereinafter, referred to as other terminal devices) in the terminal device cluster except for the source terminal device, so as to request to acquire the memory usage information of the other terminal devices. After receiving the first request message sent by the source terminal device, the other terminal device may send its memory usage information to the source terminal device, so that the source terminal device may determine, according to the memory usage information of the other terminal device, one terminal device with a relatively sufficient memory in the terminal device cluster after receiving the memory usage information sent by the other terminal device, and send a second request message to the terminal device to request to migrate an application program running on the source terminal device to the terminal device, and after receiving the second request message, the terminal device may send, to the source terminal device, a response message for representing that the source terminal device is permitted to migrate the application program running on the source terminal device to the terminal device. Thus, after the source terminal device receives the response message, the source terminal device can take the terminal device as the target terminal device.

A third possible implementation is: and the management node of the terminal equipment cluster determines the target terminal equipment in the terminal equipment cluster and informs the source terminal equipment of which terminal equipment in the terminal equipment cluster the target terminal equipment is. The method specifically comprises the following steps: the method comprises the steps that a management node of a terminal device cluster acquires memory use information of other terminal devices (hereinafter referred to as other terminal devices) except a source terminal device in the terminal device cluster, then one terminal device with sufficient memory is selected from the other terminal devices as a target terminal device according to the memory use information of the other terminal devices, and an IP address of the target terminal device is sent to the source terminal device, so that the source terminal device can determine the target terminal device to be migrated of an application program as which terminal device in the terminal device cluster is according to the IP address of the target terminal device.

And S107, the source terminal device transfers the application program from the source terminal device to the target terminal device.

In the embodiment of the present invention, after the source terminal device determines the target terminal device to which the application program is to be migrated in the terminal device cluster, the source terminal device may migrate the application program from the source terminal device to the target terminal device.

Optionally, in the embodiment of the present invention, S107 shown in fig. 4 may be specifically implemented by interaction between the source terminal device and the target terminal device, as shown in fig. 5, S107 shown in fig. 4 may be implemented by S107a-S107 c.

In this embodiment of the present invention, in order to migrate the application program from the source terminal device to the target terminal device, the source terminal device first copies a configuration file of the application program, a first program code (the first program code is a process management unit implemented based on the exo-core operating system and used for managing at least two functional units of the application program), and at least two second program codes (the second program code is one functional unit of the application program implemented based on the exo-core operating system) from the source terminal device to the target terminal device. Illustratively, the copying of the configuration file, the first process code and the at least two second program codes of the application program from the source terminal device to the target terminal device by the source terminal device may be implemented by the following S107a and S107 b.

S107a, the source terminal device sends the configuration file, the first program code and at least two second program codes of the application program to the target terminal device.

S107b, the target terminal device receives the configuration file, the first program code and at least two second program codes of the application program sent by the source terminal device.

For example, the source terminal device may send the configuration file, the first program code, and the at least two second program codes of the application program to a management node in the terminal device cluster, and then forward the configuration file, the first program code, and the at least two second program codes of the application program to the target terminal device through the management node.

In this embodiment of the present invention, after the target terminal device performs S107b, the target terminal device may further perform S107c described below.

S107c, the target terminal device runs the application on the target terminal device.

After the target terminal device receives the configuration file, the first program code and the at least two second program codes of the application program sent by the source terminal device, the target terminal device may run the application program on the target terminal device based on the configuration file, the first program code and the at least two second program codes of the application program.

In this embodiment of the present invention, since the method for running the application on the target terminal device by the target terminal device is the same as the method for running the application on the source terminal device by the source terminal device, for the method for running the application on the target terminal device by the target terminal device, reference may be made to the method for running the application on the source terminal device by the source terminal device shown in S101'-S105' in the above method embodiment, which is not described herein again.

Further, in the embodiment of the present invention, after the target terminal device runs the application on the target terminal device, the target terminal device also creates a first process virtual machine and at least two second process virtual machines, and the target terminal device loads and runs the first program code in the first process virtual machine, and loads and runs one second program code in each of the at least two second process virtual machines.

In this embodiment of the present invention, in order to enable the source terminal device to migrate the application program from the source terminal device to the target terminal device without interrupting the service provided by the application program (for example, the service provided by the application program for the user using the application program), optionally, as shown in fig. 6, after S107 shown in fig. 4, the method for running the application program according to this embodiment of the present invention may further include S108 and S109 described below.

S108, the source terminal device synchronizes data of a process management unit in a first process virtual machine on the source terminal device to the first process virtual machine on the target terminal device.

Because the data of the process management unit in the first process virtual machine on the source terminal device is data for maintaining interaction between at least two functional units of the application program, after the source terminal device migrates the application program from the source terminal device to the target terminal device, in order to ensure that the interaction between at least two functional units of the application program is not affected, the data of the process management unit in the first process virtual machine on the source terminal device may be synchronized to the first process virtual machine on the target terminal device.

In this embodiment of the present invention, the target terminal device may further execute the following S109 for each of the at least two second process virtual machines on the source terminal device.

S109, the source terminal device synchronizes data of the application program in one second process virtual machine of the at least two second process virtual machines on the source terminal device to the one second process virtual machine on the target terminal device.

It should be noted that, in the embodiment of the present invention, in the process that the target terminal device runs the application program on the target terminal device (S107c), the target terminal device may further load and run the first program code on the target terminal device, and then execute the first program code.

Optionally, in this embodiment of the present invention, the step S108 may be specifically implemented by the step S108a described below.

S108a, the source terminal device establishes communication connection between the first process virtual machine on the source terminal device and the first process virtual machine on the target terminal device, and synchronizes data of the process management unit in the first process virtual machine on the source terminal device to the first process virtual machine on the target terminal device.

Optionally, in the embodiment of the present invention, the step S109 may be specifically implemented by the step S109a described below.

S109a, the source terminal device establishes a communication connection between one of the at least two second process virtual machines on the source terminal device and the one second process virtual machine on the destination terminal device, and synchronizes data of the application program in the one second process virtual machine on the source terminal device to the one second process virtual machine on the destination terminal device.

In the embodiment of the present invention, synchronizing data of a process management unit in a first process virtual machine on a source terminal device to a first process virtual machine on a target terminal device may be understood as copying data of the process management unit in the first process virtual machine on the source terminal device to the first process virtual machine on the target terminal device in real time, so that data in the first process virtual machine on the source terminal device and data in the first process virtual machine on the target terminal device may be kept consistent (for example, data in the first process virtual machine on the source terminal device and data in the first process virtual machine on the target terminal device may be kept consistent at any time).

In the embodiment of the present invention, synchronizing the data of the application program in the one second process virtual machine on the source terminal device to the one second process virtual machine on the target terminal device may be understood as copying the data of the application program in the one second process virtual machine on the source terminal device to the one second process virtual machine on the target terminal device in real time, so that the data in the one second process virtual machine on the source terminal device and the data in the one second process virtual machine on the target terminal device may be kept consistent at any time.

Because the method for running the application program according to the embodiment of the present invention can implement that all resources required for running the multi-process application program are maintained by the application program at a sandbox level, after executing S108 and S109, all data in the sandbox running in the operating system of the source terminal device can be migrated into the sandbox running in the operating system of the target terminal device, and at this time, if the application program running in the operating system of the source terminal device is interrupted again, it is possible to not interrupt the service provided by the application program (for example, the service provided by the application program for the user using the application program) when the source terminal device migrates the application program from the source terminal device to the target terminal device.

The foregoing describes the solution provided by the embodiment of the present invention mainly from the perspective of an apparatus (e.g., the terminal device or the source terminal device) for running an application program. It is understood that the terminal device includes hardware structures and/or software modules for performing the respective functions in order to implement the functions. Those of skill in the art will readily appreciate that the present invention can be implemented in hardware or a combination of hardware and computer software, with the exemplary elements and algorithm steps described in connection with the embodiments disclosed herein. Whether a function is performed as hardware or computer software drives hardware depends upon the particular application and design constraints imposed on the solution. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present invention.

In the embodiment of the present invention, a device (for example, the terminal device or the source terminal device) running an application program may be divided into functional modules according to the method embodiment, for example, each functional module may be divided corresponding to each function, or two or more functions may be integrated into one processing module. The integrated module can be realized in a hardware mode, and can also be realized in a software functional module mode. It should be noted that, the division of the modules in the embodiment of the present invention is schematic, and is only a logic function division, and there may be another division manner in actual implementation.

For example, in the case of dividing each functional module according to each function, a schematic structural diagram of an apparatus for running an application according to an embodiment of the present invention is shown in fig. 7. In fig. 7, the apparatus for running an application may include: an acquisition module 11 and an execution module 12.

The obtaining module 11 may be configured to support the apparatus for running the application program to execute S101 executed by the terminal device in the foregoing method embodiment, or may be configured to support the apparatus for running the application program to execute S101' executed by the source terminal device in the foregoing method embodiment.

The running module 12 may be configured to support the apparatus for running the application program to execute S102, S103, S104, and S105 executed by the terminal device in the foregoing method embodiment, or may be configured to support the apparatus for running the application program to execute S102', S103', S104', and S105' executed by the source terminal device in the foregoing method embodiment.

Optionally, with reference to fig. 7, as shown in fig. 8, the apparatus for running an application may further include: a determination module 13 and a migration module 14.

The determining module 13 may be configured to support the apparatus running the application to execute S106 performed by the source terminal device in the foregoing method embodiment.

The migration module 14 is configured to support the apparatus for running the application to execute S107 (including S107a) executed by the source terminal device in the foregoing method embodiment.

Optionally, with reference to fig. 8 and as shown in fig. 9, the apparatus for running an application program may further include: a synchronization module 15.

The synchronization module 15 may be configured to support the apparatus running the application program to perform S108 (including S108a) and S109 (including S109a) performed by the source terminal device in the foregoing method embodiment.

The acquisition module 11, execution module 12, determination module 13, migration module 14, and synchronization module 15 described above may also be used to perform other processes for the techniques described herein.

It should be noted that all relevant contents of each step related to the above method embodiment may be referred to the functional description of the corresponding functional module, and are not described herein again.

Illustratively, the functions of the acquiring module 11, the executing module 12, the determining module 13, the migrating module 14 and the synchronizing module 15 may be implemented by a processor or a controller in a device running an application program. Alternatively, the description of the processor or the controller may refer to the related description of the processor 01 in the computer shown in fig. 1 in the above embodiment.

The above apparatus for running an application may further comprise a memory. Alternatively, the description of the memory can refer to the related description of the memory 02 in the computer shown in fig. 1 in the above embodiment.

Optionally, the device for running the application program may further include a bus, and the bus may include a data bus, a power bus, a control bus, a signal status bus, and the like.

The embodiment of the present invention further provides a computer-readable storage medium, where one or more programs are stored in the computer-readable storage medium, where the one or more programs include computer-executable instructions, and when a processor of the apparatus for running an application executes the instructions, the apparatus for running an application executes each step performed by a terminal device (including the source terminal device) in the method flow shown in the foregoing method embodiment.

Through the above description of the embodiments, it is clear to those skilled in the art that, for convenience and simplicity of description, the foregoing division of the functional modules is merely used as an example, and in practical applications, the above function distribution may be completed by different functional modules according to needs, that is, the internal structure of the device may be divided into different functional modules to complete all or part of the above described functions. For the specific working processes of the system, the apparatus and the unit described above, reference may be made to the corresponding processes in the foregoing method embodiments, and details are not described here again.

In the several embodiments provided in the present application, it should be understood that the disclosed system, apparatus and method may be implemented in other manners. For example, the above-described apparatus embodiments are merely illustrative, and for example, the division of the modules or units is only one logical division, and there may be other divisions when actually implemented, for example, a plurality of units or components may be combined or may be integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.

The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.

In addition, functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, and can also be realized in a form of a software functional unit.

The integrated unit, if implemented in the form of a software functional unit and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present invention may be embodied in the form of a software product, which is stored in a storage medium and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device) or a processor to execute all or part of the steps of the method according to the embodiments of the present invention. And the aforementioned storage medium includes: flash memory, removable hard drive, read only memory, random access memory, magnetic or optical disk, and the like.

The above description is only for the specific embodiments of the present invention, but the scope of the present invention is not limited thereto, and any person skilled in the art can easily conceive of the changes or substitutions within the technical scope of the present invention, and all the changes or substitutions should be covered within the scope of the present invention. Therefore, the protection scope of the present invention shall be subject to the protection scope of the appended claims.

Claims

1. A method of running an application, the method comprising:

acquiring a configuration file of an application program to be run, wherein the configuration file is used for indicating resources required by creating a process virtual machine, and the process virtual machine comprises a first process virtual machine and at least two second process virtual machines;

according to the configuration file, creating the first process virtual machine, loading and running a first program code in the first process virtual machine to form a sandbox in an operating system, wherein the first process virtual machine running the first program code runs in the sandbox, and the first program code is a process management unit realized based on an exokernel operating system;

creating the at least two second process virtual machines in the sandbox according to the configuration file, and loading and running a second program code in each of the at least two second process virtual machines to run the application program in the sandbox, wherein the second program code is a functional unit of the application program implemented based on the exokernel operating system;

the process management unit is used for maintaining data of the application program interacted between at least two functional units of the application program.

2. The method of claim 1, further comprising:

determining target equipment to be migrated of the application program;

migrating the application program from the device currently running the application program to the target device.

3. The method of claim 2, wherein the migrating the application from the device currently running the application to the target device comprises:

copying the configuration file, the first program code and at least two of the second program codes from the device currently running the application program to the target device;

and running the application program on the target device, wherein the method for running the application program on the target device is the same as the method for running the application program on the device currently running the application program.

4. The method of claim 3, further comprising:

synchronizing data of the process management unit in the first process virtual machine on the device currently running the application program to the first process virtual machine on the target device;

for each of the at least two second process virtual machines on the device currently running the application, performing the following steps:

and synchronizing data of the application program in one of the at least two second process virtual machines on the device currently running the application program to the one second process virtual machine on the target device.

5. An apparatus for running an application, the apparatus comprising: an acquisition module and an operation module;

the acquisition module is used for acquiring a configuration file of an application program to be operated, wherein the configuration file is used for indicating resources required by creating a process virtual machine, and the process virtual machine comprises a first process virtual machine and at least two second process virtual machines;

the running module is configured to create the first process virtual machine according to the configuration file acquired by the acquisition module, load and run a first program code in the first process virtual machine to form a sandbox in an operating system, where the first process virtual machine running the first program code runs in the sandbox, and the first program code is a process management unit implemented based on an exokernel operating system;

the running module is further configured to create the at least two second process virtual machines in the sandbox according to the configuration file acquired by the acquisition module, and load and run a second program code in each of the at least two second process virtual machines to run the application program in the sandbox, where the second program code is a functional unit of the application program implemented based on the exokernel operating system;

6. The apparatus of claim 5, further comprising: a determining module and a transferring module;

the determining module is configured to determine a target device to be migrated of the application program executed by the executing module;

the migration module is configured to migrate the application program from the device currently running the application program to the target device determined by the determination module.

7. The apparatus of claim 6,

the migration module is specifically configured to copy the configuration file acquired by the acquisition module, the first program code loaded and run by the running module, and the at least two second program codes from the device currently running the application to the target device determined by the determination module, so that the target device runs the application on the target device, where a method for the migration module to run the application on the target device is the same as a method for the apparatus to run the application on the device currently running the application.

8. The apparatus of claim 7, further comprising: a synchronization module;

the synchronization module is configured to synchronize data of the process management unit in the first process virtual machine created by the execution module on the device currently running the application program to the first process virtual machine on the target device;

for each of the at least two second process virtual machines on the device currently running the application:

the synchronization module is further configured to synchronize data of the application program in one of the at least two second process virtual machines created by the execution module on the device currently running the application program to the one second process virtual machine on the target device.

9. An apparatus for running an application, comprising a processor and a memory;

the memory is used for storing computer-executable instructions, and when the device for running the application program runs, the processor executes the computer-executable instructions stored by the memory, so that the device for running the application program executes the method for running the application program according to any one of claims 1 to 4.

10. The terminal equipment is characterized in that a sandbox runs in an operating system of the terminal equipment, and a first process virtual machine and at least two second process virtual machines run in the sandbox;

the first process virtual machine is used for loading and running a first program code, and the first program code is a process management unit realized based on an outer core operating system;

each of the at least two second process virtual machines is configured to load and run a second program code, where the second program code is a functional unit of an application program implemented based on the exokernel operating system;