A browser collaboration method, system, terminal, and storage medium

Abstract

This invention relates to the field of software technology, specifically to a browser collaboration method, system, terminal, and storage medium. The method includes the following steps: obtaining the running memory status of a first browser on the client; determining whether the running memory of the first browser exceeds a set threshold based on the running memory status; if it exceeds the set threshold, opening a second browser and assigning some tasks from the first browser to the second browser for execution; returning some results from the second browser to the first browser, combining these results with the local results of the first browser to obtain the execution result; adding the completed first and second browser instances to a kernel pool; if the kernel pool is at full load, destroying the completed first and second browser instances.

Description

Technical Field

[0001] This invention relates to the field of software technology, and in particular to a browser collaboration method, system, terminal, and storage medium. Background Technology

[0002] A browser is an application used to retrieve, display, and deliver web information resources. Web information resources are identified by Uniform Resource Identifiers (URIs), and can be a webpage, an image, a video, or any content presented on the web. Users can use hyperlinks to browse interconnected information through their browsers.

[0003] As the complexity of web interfaces increases and websites become richer, providing users with more and more information, browsers have limitations on the number of concurrent requests and memory usage. This leads to problems such as page lag, long white screen times, and long user response times when opening complex pages. To address this technical issue, a browser collaboration method, system, terminal, and storage medium are proposed. Summary of the Invention

[0004] To address the technical problems existing in the prior art, this invention provides a browser collaboration method, system, terminal, and storage medium. By acquiring the running status of a first browser and promptly calling other second browsers to alleviate the pressure on the first browser, it can significantly reduce lag issues and effectively improve browser efficiency. It can also reduce user waiting time and improve the user experience when browsing large amounts of data.

[0005] To achieve the above objectives, the embodiments of the present invention provide the following technical solutions:

[0006] In a first aspect, in one embodiment of the present invention, a browser collaboration method is provided, the method comprising the following steps:

[0007] Get the runtime memory status of the first browser in the client;

[0008] The system determines whether the first browser's memory usage exceeds a set threshold based on its memory status. If it does, the second browser is opened, and some tasks from the first browser are assigned to the second browser for execution.

[0009] The second browser returns a portion of the results after execution to the first browser, and the partial results are combined with the local results of the first browser to obtain the execution result.

[0010] After completing the task, the first and second browser instances are added to the kernel pool. If the kernel pool is at full load, the first and second browser instances after completing the task are destroyed.

[0011] As a further aspect of the present invention, the acquisition of the running memory status of the first browser in the client is divided into active monitoring and active reporting by the browser instance.

[0012] As a further aspect of the present invention, the active monitoring involves actively acquiring the running memory status of the first browser.

[0013] As a further aspect of the present invention, the browser instance actively reports its own operating status as a first browser.

[0014] As a further aspect of the present invention, the task includes rendering a web page interface.

[0015] As a further aspect of the present invention, some tasks in the first browser are assigned to the second browser for execution, including:

[0016] The multiple components to be rendered are distributed to multiple newly launched second browser kernel instances, and the rendering and compositing of the DOM tree and CSS tree are completed within each second browser kernel instance.

[0017] As a further aspect of the present invention, if the first browser reports its own operating status, the second browser is launched based on the blocking request issued by the first browser.

[0018] Secondly, in another embodiment provided by the present invention, a browser collaboration system is provided, the system comprising:

[0019] The system includes a status acquisition module, a status judgment module, an execution module, a post-processing module, and a browser kernel pool.

[0020] The status acquisition module is used to acquire the running memory status of the first browser in the client;

[0021] The status judgment module determines whether the running memory of the first browser exceeds a set threshold based on the running memory status. If it exceeds the set threshold, the second browser is opened, and some tasks in the first browser are assigned to the second browser for execution.

[0022] The execution module is used to return a portion of the results from the second browser to the first browser, and combine the portion of the results with the local results of the first browser to obtain the execution result;

[0023] The post-processing module is used to add the first browser instance and the second browser instance after the task is completed to the kernel pool. If the kernel pool is at full load, the first browser instance and the second browser instance after the task is completed will be destroyed.

[0024] The browser kernel pool is used to store browser kernels.

[0025] Thirdly, in another embodiment provided by the present invention, a terminal is provided, including a memory and a processor, wherein the memory stores a computer program, and the processor loads and executes the computer program to implement the steps of a browser collaboration method.

[0026] Fourthly, in another embodiment provided by the present invention, a storage medium is provided storing a computer program that, when loaded and executed by a processor, implements the steps of the browser collaboration method.

[0027] The technical solution provided by this invention has the following beneficial effects:

[0028] The browser collaboration method, system, terminal, and storage medium provided by this invention can significantly alleviate lag issues and effectively improve browser efficiency by obtaining the running status of the first browser and promptly calling other second browsers to relieve the pressure on the first browser. This can reduce user waiting time and improve the user experience when browsing large amounts of data.

[0029] These or other aspects of the invention will become more apparent from the following description of embodiments. It should be understood that the foregoing general description and the following detailed description are exemplary and explanatory only, and are not intended to limit the invention. Attached Figure Description

[0030] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other embodiments can be obtained based on these drawings without creative effort.

[0031] Figure 1 This is a flowchart of a browser collaboration method according to an embodiment of the present invention;

[0032] Figure 2 This is a detailed flowchart illustrating a browser collaboration example according to an embodiment of the present invention;

[0033] Figure 3 This is a structural block diagram of a terminal according to an embodiment of the present invention.

[0034] In the diagram: Status acquisition module-100, status judgment module-200, execution module-300, post-processing module-400, browser kernel pool-500, processor-AA1, communication interface-AA2, memory-AA3, communication bus-AA4. Detailed Implementation

[0035] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0036] The flowchart shown in the attached diagram is for illustrative purposes only and does not necessarily include all content and operations / steps, nor does it necessarily have to be performed in the order described. For example, some operations / steps can be broken down, combined, or partially merged, so the actual execution order may change depending on the actual situation.

[0037] It should be understood that the terminology used in this specification is for the purpose of describing particular embodiments only and is not intended to limit the invention. As used in this specification and the appended claims, the singular forms “a,” “an,” and “the” are intended to include the plural forms unless the context clearly indicates otherwise.

[0038] Specifically, the embodiments of the present invention will be further described below with reference to the accompanying drawings.

[0039] Please see Figure 1 , Figure 1 This is a flowchart of a browser collaboration method provided in an embodiment of the present invention, such as... Figure 1 As shown, the browser collaboration method includes steps S10 to S40.

[0040] S10. Obtain the running memory status of the first browser in the client.

[0041] In embodiments of the present invention, obtaining the running memory status of the first browser in the client is divided into active monitoring and active reporting by the browser instance.

[0042] In an embodiment of the present invention, the active monitoring is to actively obtain the running memory status of the first browser.

[0043] In an embodiment of the present invention, the browser instance actively reports its own running status as a first browser.

[0044] Specifically, it monitors the memory status of the browser instance in real time and allows setting a threshold for runtime memory. When the runtime memory of a browser instance reaches the preset threshold, it indicates that the pressure on the current instance needs to be reduced.

[0045] Because autonomous memory monitoring has certain drawbacks, it cannot accurately monitor browser request blocking. Therefore, a browser-initiated reporting system for blocking is implemented. When the primary browser needs to send multiple network requests, due to browser limitations, the number of concurrent requests may only be a few (the limit varies between browsers), and the remaining requests will be blocked. In this case, the browser proactively reports to the scheduling center, sending out the blocked requests.

[0046] S20. Determine whether the running memory of the first browser exceeds the set threshold based on the running memory status. If it exceeds the set threshold, start the second browser and assign some tasks from the first browser to the second browser for execution.

[0047] In an embodiment of the present invention, the task includes rendering a web page interface.

[0048] In an embodiment of the present invention, some tasks in the first browser are assigned to the second browser for execution, including:

[0049] The multiple components to be rendered are distributed to multiple newly launched second browser kernel instances, and the rendering and compositing of the DOM tree and CSS tree are completed within each second browser kernel instance.

[0050] Specifically, if the runtime memory status of the first browser is automatically obtained: when the memory usage of the current first browser instance is detected to be too high, a second browser instance will be launched, distributing the runtime load of the first browser to the newly launched second browser kernel. The first browser and the newly launched second browser establish communication, and the first browser kernel's tasks are distributed to the newly launched first browser. These tasks include, but are not limited to, the browser's rendering work. For example, if the browser detects that there are multiple large data components to be rendered in the interface memory, it can distribute these components to multiple newly launched browser kernel instances, where the rendering and compositing of the DOM tree and CSS tree are completed within each browser kernel instance.

[0051] In an embodiment of the present invention, if the first browser reports its own running status, the second browser is launched based on the blocking request issued by the first browser.

[0052] S30. Return a portion of the results from the second browser to the first browser, and combine the portion of the results with the local results of the first browser to obtain the execution result.

[0053] There is a communication channel between the first browser and the second browser.

[0054] The second browser returns a partial result based on the blocking request, and then compresses and packages that partial result.

[0055] The browser then displays the execution results to the user, thus completing the execution of a full task.

[0056] S40. Add the first and second browser instances after the task is completed to the kernel pool. If the kernel pool is at full load, destroy the first and second browser instances after the task is completed.

[0057] Specifically, after the second browser instance has completed its assigned tasks, maintaining too many browser kernel instances would consume system memory. Immediately shutting down browser kernel instances after each task completion would increase the workload. Therefore, this system employs a browser kernel pool approach, maintaining a manageable kernel pool and adding inactive kernel instances to it. When a kernel needs to be started, it is retrieved directly from the pool, eliminating the pressure of destroying kernels each time and making the system run more smoothly. Only when the number of kernels to be started or destroyed exceeds the kernel pool's capacity is a shutdown command executed on browser instances currently without tasks to release their occupied system space; the system continues to monitor surviving browser instances.

[0058] This invention obtains the running status of the first browser and promptly calls upon other second browsers to alleviate the pressure on the first browser, significantly reducing lag issues and effectively improving browser efficiency. It can also reduce user waiting time and enhance the user experience when browsing large amounts of data.

[0059] It should be understood that although the above description follows a certain order, these steps are not necessarily executed in that order. Unless otherwise expressly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, some steps in this embodiment may include multiple steps or multiple stages, which are not necessarily completed at the same time, but may be executed at different times. The execution order of these steps or stages is not necessarily sequential, but may be performed alternately or in turn with other steps or at least a portion of the steps or stages in other steps.

[0060] In one embodiment, see Figure 2 As shown, an embodiment of the present invention also provides a browser collaboration system, which includes a status acquisition module 100, a status judgment module 200, an execution module 300, a post-processing module 400, and a browser kernel pool 500.

[0061] The status acquisition module 100 is used to acquire the running memory status of the first browser in the client.

[0062] In an embodiment of the present invention, the active monitoring is to actively obtain the running memory status of the first browser.

[0063] In an embodiment of the present invention, the browser instance actively reports its own running status as a first browser.

[0064] In an embodiment of the present invention, the status acquisition module 100 can obtain the running memory status of the first browser in the client through active monitoring and active reporting by the browser instance.

[0065] The status judgment module 200 determines whether the running memory of the first browser exceeds a set threshold based on the running memory status. If it exceeds the set threshold, the second browser is opened, and some tasks in the first browser are assigned to the second browser for execution.

[0066] In an embodiment of the present invention, the task includes rendering a web page interface.

[0067] In an embodiment of the present invention, some tasks in the first browser are assigned to the second browser for execution, including:

[0068] The multiple components to be rendered are distributed to multiple newly launched second browser kernel instances, and the rendering and compositing of the DOM tree and CSS tree are completed within each second browser kernel instance.

[0069] Specifically, if the runtime memory status of the first browser is automatically obtained: when the memory usage of the current first browser instance is detected to be too high, a second browser instance will be launched, distributing the runtime load of the first browser to the newly launched second browser kernel. The first browser and the newly launched second browser establish communication, and the first browser kernel's tasks are distributed to the newly launched first browser. These tasks include, but are not limited to, the browser's rendering work. For example, if the browser detects that there are multiple large data components to be rendered in the interface memory, it can distribute these components to multiple newly launched browser kernel instances, where the rendering and compositing of the DOM tree and CSS tree are completed within each browser kernel instance.

[0070] In an embodiment of the present invention, if the first browser reports its own running status, the second browser is launched based on the blocking request issued by the first browser.

[0071] The execution module 300 is used to return part of the results after the second browser runs to the first browser, and combine the part of the results with the local results of the first browser to obtain the execution result.

[0072] There is a communication channel between the first browser and the second browser.

[0073] The second browser returns a partial result based on the blocking request, and then compresses and packages that partial result.

[0074] The browser then displays the execution results to the user, thus completing the execution of a full task.

[0075] The post-processing module 400 is used to add the first browser instance and the second browser instance after the task is completed to the kernel pool. If the kernel pool is at full load, the first browser instance and the second browser instance after the task is completed will be destroyed.

[0076] Specifically, after the second browser instance has completed its assigned tasks, maintaining too many browser kernel instances would consume system memory. Immediately shutting down browser kernel instances after each task completion would increase the workload. Therefore, this system employs a browser kernel pool approach, maintaining a manageable kernel pool and adding inactive kernel instances to it. When a kernel needs to be started, it is retrieved directly from the pool, eliminating the pressure of destroying kernels each time and making the system run more smoothly. Only when the number of kernels to be started or destroyed exceeds the kernel pool's capacity is a shutdown command executed on browser instances currently without tasks to release their occupied system space; the system continues to monitor surviving browser instances.

[0077] The browser kernel pool 500 is used to store browser kernels.

[0078] This invention obtains the running status of the first browser and promptly calls upon other second browsers to alleviate the pressure on the first browser, significantly reducing lag issues and effectively improving browser efficiency. It can also reduce user waiting time and enhance the user experience when browsing large amounts of data.

[0079] In one embodiment, see Figure 3 As shown, an embodiment of the present invention also provides a terminal, including a processor AA1, a communication interface AA2, a memory AA3, and a communication bus AA4, wherein the processor AA1, the communication interface AA2, and the memory AA3 communicate with each other through the communication bus AA4.

[0080] Memory AA3 is used to store computer programs;

[0081] When processor AA1 executes the computer program stored in memory AA3, it executes the browser collaboration method described above. When executing instructions, the processor implements the steps in the above method embodiment:

[0082] S10. Obtain the running memory status of the first browser in the client.

[0083] In embodiments of the present invention, obtaining the running memory status of the first browser in the client is divided into active monitoring and active reporting by the browser instance.

[0084] In an embodiment of the present invention, the active monitoring is to actively obtain the running memory status of the first browser.

[0085] In an embodiment of the present invention, the browser instance actively reports its own running status as a first browser.

[0086] Specifically, it monitors the memory status of the browser instance in real time and allows setting a threshold for runtime memory. When the runtime memory of a browser instance reaches the preset threshold, it indicates that the pressure on the current instance needs to be reduced.

[0087] Because autonomous memory monitoring has certain drawbacks, it cannot accurately monitor browser request blocking. Therefore, a browser-initiated reporting system for blocking is implemented. When the primary browser needs to send multiple network requests, due to browser limitations, the number of concurrent requests may only be a few (the limit varies between browsers), and the remaining requests will be blocked. In this case, the browser proactively reports to the scheduling center, sending out the blocked requests.

[0088] S20. Determine whether the running memory of the first browser exceeds the set threshold based on the running memory status. If it exceeds the set threshold, start the second browser and assign some tasks from the first browser to the second browser for execution.

[0089] In an embodiment of the present invention, the task includes rendering a web page interface.

[0090] In an embodiment of the present invention, some tasks in the first browser are assigned to the second browser for execution, including:

[0091] The multiple components to be rendered are distributed to multiple newly launched second browser kernel instances, and the rendering and compositing of the DOM tree and CSS tree are completed within each second browser kernel instance.

[0092] Specifically, if the runtime memory status of the first browser is automatically obtained: when the memory usage of the current first browser instance is detected to be too high, a second browser instance will be launched, distributing the runtime load of the first browser to the newly launched second browser kernel. The first browser and the newly launched second browser establish communication, and the first browser kernel's tasks are distributed to the newly launched first browser. These tasks include, but are not limited to, the browser's rendering work. For example, if the browser detects that there are multiple large data components to be rendered in the interface memory, it can distribute these components to multiple newly launched browser kernel instances, where the rendering and compositing of the DOM tree and CSS tree are completed within each browser kernel instance.

[0093] In an embodiment of the present invention, if the first browser reports its own running status, the second browser is launched based on the blocking request issued by the first browser.

[0094] S30. Return a portion of the results from the second browser to the first browser, and combine the portion of the results with the local results of the first browser to obtain the execution result.

[0095] There is a communication channel between the first browser and the second browser.

[0096] The second browser returns a partial result based on the blocking request, and then compresses and packages that partial result.

[0097] The browser then displays the execution results to the user, thus completing the execution of a full task.

[0098] S40. Add the first and second browser instances after the task is completed to the kernel pool. If the kernel pool is at full load, destroy the first and second browser instances after the task is completed.

[0099] Specifically, after the second browser instance has completed its assigned tasks, maintaining too many browser kernel instances would consume system memory. Immediately shutting down browser kernel instances after each task completion would increase the workload. Therefore, this system employs a browser kernel pool approach, maintaining a manageable kernel pool and adding inactive kernel instances to it. When a kernel needs to be started, it is retrieved directly from the pool, eliminating the pressure of destroying kernels each time and making the system run more smoothly. Only when the number of kernels to be started or destroyed exceeds the kernel pool's capacity is a shutdown command executed on browser instances currently without tasks to release their occupied system space; the system continues to monitor surviving browser instances.

[0100] This invention obtains the running status of the first browser and promptly calls upon other second browsers to alleviate the pressure on the first browser, significantly reducing lag issues and effectively improving browser efficiency. It can also reduce user waiting time and enhance the user experience when browsing large amounts of data.

[0101] The communication bus mentioned in the above terminal can be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus, etc. This communication bus can be divided into address bus, data bus, control bus, etc. For ease of illustration, only one thick line is used to represent it in the diagram, but this does not mean that there is only one bus or one type of bus.

[0102] The communication interface is used for communication between the aforementioned terminal and other devices.

[0103] The memory may include random access memory (RAM) or non-volatile memory, such as at least one disk storage device. Optionally, the memory may also be at least one storage device located remotely from the aforementioned processor.

[0104] The processors mentioned above can be general-purpose processors, including central processing units (CPUs), network processors (NPs), etc.; they can also be 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, or discrete hardware components.

[0105] The terminal includes user equipment and network equipment. The user equipment includes, but is not limited to, computers, smartphones, and PDAs. The network equipment includes, but is not limited to, a single network server, a server group consisting of multiple network servers, or a cloud based on cloud computing, which is a type of distributed computing consisting of a super virtual computer composed of a group of loosely coupled computers. The terminal can operate independently to implement this invention, or it can connect to a network and interact with other terminals on the network to implement this invention. The network in which the terminal is located includes, but is not limited to, the Internet, wide area network (WAN), metropolitan area network (MAN), local area network (LAN), and VPN network.

[0106] It should also be understood that the term "and / or" as used in this specification and the appended claims refers to any combination of one or more of the associated listed items and all possible combinations, and includes such combinations.

[0107] In one embodiment of the present invention, a storage medium is also provided, on which a computer program is stored, which, when executed by a processor, implements the steps in the above method embodiments:

[0108] S10. Obtain the running memory status of the first browser in the client.

[0109] In embodiments of the present invention, obtaining the running memory status of the first browser in the client is divided into active monitoring and active reporting by the browser instance.

[0110] In an embodiment of the present invention, the active monitoring is to actively obtain the running memory status of the first browser.

[0111] In an embodiment of the present invention, the browser instance actively reports its own running status as a first browser.

[0112] Specifically, it monitors the memory status of the browser instance in real time and allows setting a threshold for runtime memory. When the runtime memory of a browser instance reaches the preset threshold, it indicates that the pressure on the current instance needs to be reduced.

[0113] Because autonomous memory monitoring has certain drawbacks, it cannot accurately monitor browser request blocking. Therefore, a browser-initiated reporting system for blocking is implemented. When the primary browser needs to send multiple network requests, due to browser limitations, the number of concurrent requests may only be a few (the limit varies between browsers), and the remaining requests will be blocked. In this case, the browser proactively reports to the scheduling center, sending out the blocked requests.

[0114] S20. Determine whether the running memory of the first browser exceeds the set threshold based on the running memory status. If it exceeds the set threshold, start the second browser and assign some tasks from the first browser to the second browser for execution.

[0115] In an embodiment of the present invention, the task includes rendering a web page interface.

[0116] In an embodiment of the present invention, some tasks in the first browser are assigned to the second browser for execution, including:

[0117] The multiple components to be rendered are distributed to multiple newly launched second browser kernel instances, and the rendering and compositing of the DOM tree and CSS tree are completed within each second browser kernel instance.

[0118] Specifically, if the runtime memory status of the first browser is automatically obtained: when the memory usage of the current first browser instance is detected to be too high, a second browser instance will be launched, distributing the runtime load of the first browser to the newly launched second browser kernel. The first browser and the newly launched second browser establish communication, and the first browser kernel's tasks are distributed to the newly launched first browser. These tasks include, but are not limited to, the browser's rendering work. For example, if the browser detects that there are multiple large data components to be rendered in the interface memory, it can distribute these components to multiple newly launched browser kernel instances, where the rendering and compositing of the DOM tree and CSS tree are completed within each browser kernel instance.

[0119] In an embodiment of the present invention, if the first browser reports its own running status, the second browser is launched based on the blocking request issued by the first browser.

[0120] S30. Return a portion of the results from the second browser to the first browser, and combine the portion of the results with the local results of the first browser to obtain the execution result.

[0121] There is a communication channel between the first browser and the second browser.

[0122] The second browser returns a partial result based on the blocking request, and then compresses and packages that partial result.

[0123] The browser then displays the execution results to the user, thus completing the execution of a full task.

[0124] S40. Add the first and second browser instances after the task is completed to the kernel pool. If the kernel pool is at full load, destroy the first and second browser instances after the task is completed.

[0125] Specifically, after the second browser instance has completed its assigned tasks, maintaining too many browser kernel instances would consume system memory. Immediately shutting down browser kernel instances after each task completion would increase the workload. Therefore, this system employs a browser kernel pool approach, maintaining a manageable kernel pool and adding inactive kernel instances to it. When a kernel needs to be started, it is retrieved directly from the pool, eliminating the pressure of destroying kernels each time and making the system run more smoothly. Only when the number of kernels to be started or destroyed exceeds the kernel pool's capacity is a shutdown command executed on browser instances currently without tasks to release their occupied system space; the system continues to monitor surviving browser instances.

[0126] This invention obtains the running status of the first browser and promptly calls upon other second browsers to alleviate the pressure on the first browser, significantly reducing lag issues and effectively improving browser efficiency. It can also reduce user waiting time and enhance the user experience when browsing large amounts of data.

[0127] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Furthermore, any references to memory, storage, databases, or other media used in the embodiments provided by this invention can include at least one of non-volatile and volatile memory.

[0128] It should be understood that, as used herein, the singular form "a" is intended to include the plural form as well, unless the context clearly supports an exception. It should also be understood that, as used herein, "and / or" refers to any and all possible combinations of one or more of the associatedly listed items. The embodiment numbers disclosed above are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0129] Those skilled in the art should understand that the discussion of any of the above embodiments is merely exemplary and is not intended to imply that the scope of the invention (including the claims) is limited to these examples. Within the framework of the invention, technical features of the above embodiments or different embodiments can be combined, and many other variations of different aspects of the invention exist, which are not provided in the details for the sake of brevity. Therefore, any omissions, modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the invention should be included within the protection scope of the invention.

Claims

1. A method of browser collaboration, the method comprising: The method comprises: acquiring a running memory state of a first browser in a client, wherein the acquiring of the running memory state of the first browser in the client comprises self-feedback of the first browser on its own running memory state; determining whether the running memory of the first browser exceeds a set threshold according to the running memory state, and if so, starting a second browser and assigning part of tasks in the first browser to the second browser for execution; the starting of the second browser comprises starting the second browser based on a blocking request sent by the first browser if the first browser self-feeds back its own running state; returning part of results after the running of the second browser to the first browser, combining the part of results with local results of the first browser to obtain an execution result; adding the first browser instance and the second browser instance after the completion of the tasks to a kernel pool, and if the kernel pool is in a full load state, destroying the first browser instance and the second browser instance after the completion of the tasks.

2. The browser collaboration method of claim 1, wherein, The acquiring of the running memory state of the first browser in the client further comprises active monitoring to acquire the running memory state of the first browser.

3. The browser collaboration method of claim 2, wherein, The active monitoring is active acquisition of the running memory state of the first browser.

4. The browser collaboration method of claim 1, wherein, The part of tasks comprises webpage interface rendering.

5. The browser collaboration method of claim 4, wherein, The assigning of the part of tasks in the first browser to the second browser for execution comprises: distributing a plurality of components to be rendered to a plurality of newly started second browser kernel instances, and completing rendering and synthesis of DOM trees and CSS trees in each second browser kernel instance.

6. A system of browser collaboration, characterized by The system comprises a state acquisition module, a state determination module, an execution module, a post-processing module and a browser kernel pool; The state acquisition module is configured to acquire a running memory state of a first browser in a client, wherein the acquiring of the running memory state of the first browser in the client comprises self-feedback of the first browser on its own running memory state; The state determination module is configured to determine whether the running memory of the first browser exceeds a set threshold according to the running memory state, and if so, start a second browser and assign part of tasks in the first browser to the second browser for execution; the starting of the second browser comprises starting the second browser based on a blocking request sent by the first browser if the first browser self-feeds back its own running state; The execution module is configured to return part of results after the running of the second browser to the first browser, combine the part of results with local results of the first browser to obtain an execution result; The post-processing module is configured to add the first browser instance and the second browser instance after the completion of the tasks to a kernel pool, and if the kernel pool is in a full load state, destroy the first browser instance and the second browser instance after the completion of the tasks; The browser kernel pool is configured to store browser kernels. 7.A terminal comprising a memory and a processor, wherein the memory stores a computer program, and the processor loads and executes the computer program to implement steps of the browser cooperation method according to any one of claims 1-5.

8. A storage medium storing a computer program which, when loaded and executed by a processor, implements the steps of the browser collaboration method according to any one of claims 1 to 5.

Images