A dynamic resource management method and terminal

Abstract

This invention relates to the field of game resource updates, and more particularly to a dynamic resource management method and terminal. The invention provides a dynamic resource management method applied to a server, comprising: obtaining an environment variable identifier; determining at least one scene variable corresponding to the environment variable identifier; constructing a linked list structure for the scene variable; generating access link information for the scene variable based on the linked list structure; and sending the access link information to the client, so that the client executes access operations sequentially according to the access link information. This significantly reduces the number of client restarts caused by resource updates, improves the flexibility and efficiency of resource loading, optimizes the user experience, and simplifies the remote deployment process.

Description

Technical Field

[0001] This invention relates to the field of game resource updates, and more particularly to a dynamic resource management method and terminal. Background Technology

[0002] In game development, resource loading mechanisms directly impact user experience and deployment efficiency. In existing solutions, web clients benefit from server-side resource storage, automatically loading resources from a temporary cache when users enter the game, achieving real-time updates and fragmented loading. In contrast, PC clients typically use a broadcast mechanism, relying on a resource server to broadcast resource numbers. The client must check and load existing local resource packages based on these numbers; if none are found, the resource cannot be displayed. This necessitates downloading the complete resource package, decompressing it, and restarting the client for updates to take effect. Therefore, existing technologies present a core contradiction: while web clients can conveniently update fragmented resources in real time, PC clients, due to their reliance on local resource packages, must restart to complete updates, resulting in user experience interruptions, inefficient resource loading, and cumbersome remote deployment procedures. Summary of the Invention

[0003] The technical problem to be solved by this invention is to provide a dynamic resource management method and terminal that reduces the number of loading times and eliminates the need to restart the client.

[0004] A dynamic resource management method, applied to a server, the method comprising: Get environment variable identifiers; Determine at least one scenario variable corresponding to the environmental variable identifier; A linked list structure is constructed for the scene variables, and access link information of the scene variables is generated based on the linked list structure; The access link information is sent to the client so that the client can perform access operations sequentially according to the access link information.

[0005] To solve the above-mentioned technical problems, another technical solution adopted by the present invention is as follows: A dynamic resource management method, applied to a client, the method comprising: Retrieve predefined resource fixed variable templates; Receive access link information from the server; Based on the access link information, determine the dynamic variables to be loaded and their corresponding target resource identifiers; Allocate dynamic memory for the dynamic variable to be loaded, and load the corresponding resource data into the dynamic memory according to the target resource identifier.

[0006] To solve the above-mentioned technical problems, another technical solution adopted by the present invention is as follows: A dynamic resource loading terminal includes a memory, a processor, and a computer program stored in the memory and running on the processor. When the processor executes the computer program, it implements the aforementioned dynamic resource management method.

[0007] The beneficial effects of this invention are as follows: This invention determines the current operating environment or configuration by obtaining environment variable identifiers. It identifies at least one scenario variable corresponding to this identifier, clarifying the specific set of resources that need to be dynamically loaded. A linked list structure is constructed for these scenario variables, and access link information is generated based on this structure. This step organizes discrete resources into an ordered, traversable loading sequence. Finally, the access link information is sent to the client, which then performs access operations sequentially to load resources on demand. Compared to existing technologies where PC clients rely on broadcast mechanisms and must restart the client to load the complete resource package, this invention solves the problems of cumbersome update processes and user experience interruptions. Existing solutions cannot dynamically identify and load incremental or changed fragmented resources during resource updates, necessitating application restarts. This invention generates and sends structured access link information, guiding the client to dynamically load resources corresponding to scenario variables in a specific order, achieving hot resource updates without requiring client restarts. This significantly reduces the number of client restarts due to resource updates, improves the flexibility and efficiency of resource loading, optimizes the user experience, and simplifies remote deployment processes. Attached Figure Description

[0008] Figure 1 A flowchart illustrating the steps of implementing a dynamic resource management method on the server side according to an embodiment of the present invention; Figure 2 A flowchart illustrating the steps of implementing a dynamic resource management method on a client side according to an embodiment of the present invention; Figure 3 This is a schematic diagram of the structure of a terminal provided in an embodiment of the present invention; Figure 4 A flowchart illustrating the resource storage configuration process of a dynamic resource management method implemented on a client side, as provided in an embodiment of the present invention. Figure 5 A flowchart illustrating the resource distribution process implemented on the server side of a dynamic resource management method provided in this embodiment of the invention. Figure 6 A flowchart illustrating the resource download process implemented on a client side for a dynamic resource management method provided in this embodiment of the invention; Label Explanation: 1. A terminal; 2. A processor; 3. A memory. Detailed Implementation

[0009] To explain in detail the technical content, objectives, and effects of the present invention, the following description is provided in conjunction with the embodiments and accompanying drawings.

[0010] The following describes a dynamic resource management method of the present invention, applied to the server side, with reference to the appendix. Figure 1 ,include: Step 110: Obtain the environment variable identifier; where the environment variable identifier refers to the name used to uniquely identify a static environment variable, which contains a set of related scenario variables.

[0011] Step 120: Determine at least one scenario variable corresponding to the environment variable identifier; wherein, the scenario variable refers to a variable parameter defined under a specific environment variable and used to describe the specific resource attributes or states under that environment.

[0012] Step 130: Construct a linked list structure for the scene variables, and generate access link information for the scene variables based on the linked list structure; where the linked list structure refers to a data structure in which each node contains a data part and a pointer to the next node, used to organize dynamic variables in sequence; access link information refers to data describing how to access each node in the linked list structure in sequence to obtain the complete resource combination.

[0013] Step 140: Send the access link information to the client so that the client can perform access operations sequentially according to the access link information; where the client refers to the application or game program running on the user's device; the access operation refers to the process by which the client reads, loads and applies the resource data corresponding to each scene variable from memory or disk in sequence according to the received access link information.

[0014] As described above, this embodiment determines the current operating environment or configuration by obtaining environment variable identifiers. It identifies at least one scenario variable corresponding to this identifier, clarifying the specific set of resources that need to be dynamically loaded. A linked list structure is constructed for these scenario variables, and access link information is generated based on this structure. This step organizes discrete resources into an ordered, traversable loading sequence. Finally, the access link information is sent to the client, which then performs access operations sequentially to load resources on demand. Compared to existing technologies where PC clients rely on broadcast mechanisms and must restart the client to load the complete resource package, this invention solves the problems of cumbersome update processes and user experience interruptions. Existing solutions cannot dynamically identify and load incremental or changed fragmented resources during resource updates, necessitating application restarts. This invention generates and sends structured access link information, guiding the client to dynamically load resources corresponding to scenario variables in a specific order, achieving hot resource updates without requiring client restarts. This significantly reduces the number of client restarts due to resource updates, improves the flexibility and efficiency of resource loading, optimizes the user experience, and simplifies the remote deployment process.

[0015] In one embodiment of this application, step 130, constructing a linked list structure for the scene variables, includes: Step 210: Construct a doubly linked list or a closed-loop linked list for the scene variables. A doubly linked list is a linked list data structure in which each node contains pointers to the previous and next nodes, allowing forward and backward traversal. A closed-loop linked list is a linked list data structure in which the pointer of the last node points to the first node, forming a circular access path. For example, the linked list access mode is to point to the next linked list and then all the way to the first position of the linked list, forming a closed loop.

[0016] As described above, this embodiment uses a doubly linked list or a closed-loop linked list structure to organize scene variables, providing a more flexible traversal method. A doubly linked list supports bidirectional access, facilitating backtracking or order adjustment during resource loading; a closed-loop linked list ensures the continuity of the access path, avoiding null pointer exceptions after the access endpoint. This enhances the structural controllability and robustness of the resource access chain, enabling clients to load resources more efficiently and reliably in sequence, thereby optimizing the dynamic resource management process.

[0017] In one embodiment of this application, step 120, determining at least one scene variable corresponding to the environment variable identifier, includes: Step 310: Based on the environment variable identifier, set multiple scene variables that match the environment variable identifier. The scene variables include resource identifiers. The resource identifier refers to a string or code used to uniquely identify a specific resource. For example, "c0012" represents the T-shirt type, "00e1" represents the clothing style, and "0157" represents the color scheme.

[0018] As described above, this embodiment provides a precise index for each dynamically managed resource by incorporating resource identifiers as part of the scene variables. Using standardized resource identifiers enables accurate resource matching and rapid retrieval. This reduces search overhead and error rates during resource loading, ensuring that the client can accurately locate and load the specific resource corresponding to the current environment variables, thereby improving the accuracy and efficiency of resource loading.

[0019] In one embodiment of this application, generating access link information for scene variables based on a linked list structure includes: Step 410: Based on the linked list structure, generate access link information for scene variables. The access link information includes placeholders with a predetermined format corresponding to the nodes in the linked list structure. The predetermined format placeholders are strings aligned to a fixed length (e.g., 4 bytes) and used to represent resource identifiers in the linked list nodes. Multiple placeholders are concatenated to form complete access link information. For example, the string "c001200e10157" represents an access link composed of three 4-byte placeholders "c0012", "00e1", and "0157", corresponding to the three resource nodes "T-shirt type", "T-shirt component", and "component color" respectively. The client parses the placeholder sequence based on this string and accesses the resources corresponding to each node in sequence.

[0020] As described above, this embodiment uses placeholders with a fixed format to encode the access link, generating a compact and uniform instruction sequence. This standardized placeholder sequence simplifies the parsing logic. The client can efficiently parse the string and access the resource node corresponding to each placeholder sequentially. This reduces the complexity of the client processing access link information, improves the speed and reliability of instruction execution, and thus accelerates the loading process of dynamic resources.

[0021] In one embodiment of this application, it further includes: Step 510: Set fixed and dynamic variables in the scene variables; where fixed variables refer to resource variables that are predefined locally on the client and are not controlled by the server, such as character skeletons; dynamic variables refer to resource variables that are controlled by the server and can be updated in real time, such as hair color, clothing style and color.

[0022] Step 520: Construct a linked list structure for the dynamic variables. The linked list structure includes linked list nodes, and each linked list node contains a resource identifier and its corresponding resource data. Here, a linked list node refers to a single element in the linked list structure, which contains a resource identifier and the actual resource data corresponding to that identifier. Resource data refers to specific game resource content, such as images, audio, or configuration files.

[0023] As described above, this embodiment achieves fine-grained resource control by distinguishing between fixed and dynamic variables and organizing the dynamic variables into a linked list structure for management. This embodiment allows the server to adjust and distribute updates only to the dynamic variables that need to be updated. This significantly reduces the amount of data transmitted over the network and the scale of data that the client needs to process, enabling incremental updates of resources, thereby improving update efficiency and saving network bandwidth and client computing resources.

[0024] This invention also provides a dynamic resource management method, applied to a client, as shown in the appendix. Figure 2 ,include: Step 610: Obtain a predefined resource fixed variable template; where the resource fixed variable template refers to a resource framework stored locally on the client. This framework defines the structure of the fixed variable part and the dynamic variable part of the resource, and is used to guide the client on how to parse and populate the resource data sent by the server. For example, the clothing resource template defines fixed variables such as body, collar, front piece, back piece, and hem.

[0025] Step 620: Receive access link information from the server; where the server refers to a program running on a remote server, responsible for managing resource updates and distributing access link information.

[0026] Step 630: Based on the access link information, determine the dynamic variables to be loaded and their corresponding target resource identifiers; wherein, the dynamic variables to be loaded refer to the dynamic variables that need to be loaded or updated by the client according to the access link information; the target resource identifier refers to the resource identifier corresponding to the dynamic variables to be loaded, which is used to obtain resource data from the server or local machine.

[0027] Step 640: Allocate dynamic memory for the dynamic variables to be loaded, and load the corresponding resource data into the dynamic memory according to the target resource identifier; where dynamic memory refers to the memory space temporarily allocated during the runtime of the client program, used to store the resource data of the dynamic variables; loading refers to the process of obtaining resource data from the server and storing it into the dynamic memory.

[0028] As described above, this embodiment enables the client to dynamically load and update resources based on local templates and structured instructions issued by the server. Compared to existing technologies where the client must restart to load a complete, pre-packaged resource package, this method achieves hot resource updates without restarting. The client only needs to load the specified dynamic variable resources according to the access link information and combine them with the local fixed variable template to complete the resource combination. This avoids application interruptions caused by resource updates, improving user experience and the flexibility of resource management.

[0029] In one embodiment of this application, step 630, determining the dynamic variable to be loaded and its corresponding target resource identifier based on the access link information, includes: Step 710: Determine if there are any dynamic variables to be loaded. If so, obtain the target resource identifier and resource data corresponding to the dynamic variables to be loaded. As described above, this embodiment ensures that resource loading operations are executed on demand by using a logic of first determining and then acquiring. This embodiment only performs subsequent acquisition operations when it is confirmed that there are dynamic variables to be loaded. This avoids unnecessary resource requests and memory consumption, making the resource loading process more efficient and resource-saving, and is particularly suitable for scenarios with high resource update frequency or a large number of dynamic variables.

[0030] In one embodiment of this application, loading corresponding resource data based on the target resource identifier includes: Step 810: Compare the resource data corresponding to the target resource identifier with the hash value of the existing local resources; where the existing local resources refer to the resource files stored on the client's local disk; the hash value refers to a fixed-length string obtained by calculating the resource data through a hash function, used to verify the integrity and version consistency of the resource data. The hash value is calculated by a hash algorithm, including MD5 (Message Digest Algorithm 5).

[0031] Step 820: If the comparison is inconsistent, the resource data from the server is filled into the dynamic memory allocated by the dynamic variable; where the resource data from the server refers to the latest version of the resource data stored on the server; filling refers to the operation of writing the resource data into the dynamic memory.

[0032] Step 830: If the comparison is consistent, the resource data already mapped in memory is loaded directly; where the resource data already mapped in memory refers to the resource data that has been loaded into the client's memory, which the client can use directly without re-downloading.

[0033] As described above, this embodiment achieves resource version control and cache reuse by introducing a hash value comparison mechanism. This embodiment identifies unchanged resources and directly reuses existing resource data in the client's local storage or memory. This reduces unnecessary data transmission and repeated loading, lowers network load, speeds up resource loading, and improves client response performance.

[0034] In one embodiment of this application, step 620, receiving access link information from the server, includes: Step 910: Receive access link information and resource data corresponding to the resource identifier in the access link information; As described above, this embodiment achieves synchronous transmission of instructions and data by sending the access link information along with the resource data it points to. This embodiment packages and transmits the metadata and entity data required for a single update. This reduces the number of network interactions between the client and server, lowers request latency, and makes the resource update process more centralized and efficient, thereby improving the overall resource loading throughput.

[0035] The dynamic resource management method and terminal of the present invention can be applied to online games, especially online game resource management, and will be described below through specific implementation methods.

[0036] See attached document Figure 5 The first embodiment of the present invention includes steps A to G: Step A: Set Environment Variables. The server initializes and sets an environment variable, denoted as evName, based on the target environment. This corresponds to step 110 above. It's important to note that each runtime environment has a unique environment variable name, and each specific scene running within that environment has its own scene variable name. This corresponds to step 120 above. For example, an environment variable named 'color' can include specific color values ​​such as 'red' and 'blue'. Environment variables are static variables, while their members are dynamic variables. The server will subsequently use this static environment variable to retrieve and organize its associated dynamic member variables.

[0037] Step B: The server attempts to construct environment member links for the environment variable evName set in Step A. These links are intended to organize all dynamic members under this environment variable in a structured manner. The server determines whether this construction operation was successful. (This corresponds to step 130 above.)

[0038] Step C: If the result of step B is negative, i.e., the environment member link building fails, the server executes the logic to rebuild the environment variable links. The process then returns to step A to attempt to reset the environment variables and begin a new build process. This corresponds to step 130 above.

[0039] Step D: If the result of step B is yes, meaning the environment member link is successfully constructed, the server links the current linked list member to the next linked list member. The dynamic variables are stored in a dedicated access link, which is constructed using a doubly linked list data structure. This design allows the server or client to traverse the linked list forward or backward, continuously accessing the next or previous dynamic variable node, thus efficiently completing sequential access to the entire variable data set. This corresponds to step 130 above.

[0040] Step E: The server determines whether the currently generated sequence of link nodes constitutes a complete access link that conforms to preset logic. A complete access link defines the variable access order from macro to micro, from main to attachment. For example, a complete link can be represented as: listr(rose) -> listc(clothes) -> lists(skin) -> listc(color), which clearly indicates the access path from character (rose) to clothing (clothes), then to skin (skin), and finally to color (color). This corresponds to step 130 above.

[0041] Step F: If the result of step E is negative, meaning the current link is not yet complete, the server continues to generate new link nodes according to the variable rules. The process then returns to step D, where the new node is used as the current node and linked to the next member of the linked list, until the link is complete. This corresponds to step 130 above.

[0042] Step G: Send the linked list and resource identifiers to the client. If the result of step E is yes, that is, a complete access link has been generated, the server sends the link structure and its corresponding resource identifier (ID) to the client. The resource identifier encodes the specific composition of the variable in a compact format. For example, for a clothing variable, its identifier may be stored consecutively in multiple fixed-length fields (e.g., 4 bytes): the first field (e.g., c0012) represents the category (e.g., T-shirt), the second field (e.g., 00e1) represents the specific style under the category, and the third field (e.g., 0157) represents the specific color scheme of the style. The data stream sent by the server contains all such identifiers, and the client can calculate the number of variables to be processed by parsing the total length of the data stream and the fixed length of each identifier (e.g., 4 bytes) (e.g., total length 12 bytes / 4 bytes per identifier = 3 identifiers, that is, 3 levels of variable information need to be processed). This corresponds to step 140 above.

[0043] See attached document Figure 6 The second embodiment of the present invention includes steps S1 to S9: Step S1: The client generates a resource fixed variable template. The resource fixed variable template is a predefined resource parsing framework that divides the resource structure into a static traversal part and a dynamic variable part. Taking clothing resources in the game as an example, its components (such as the body, collar, front piece, back piece, and hem) are defined as fixed variables, forming a static template framework. The purpose of this template is to inform the client of the resource parsing rules in advance, so that the server only needs to fill the static traversal part of the template with real-time updated data (such as clothing style and texture) to form a complete resource access chain. The client operates according to this chain, thus avoiding the situation where players have to wait for the complete resource package to be downloaded and updated before they can play the game, realizing dynamic and modular updates of resources. (See Appendix) Figure 4 Step S1 includes steps S101 to S108: Step S101: The client initializes and sets a scene variable, denoted as evName.

[0044] Step S102: The client determines whether the scene variable evName contains both fixed and dynamic variables. The fixed variables are variable elements that can be determined locally on the client without server guidance, such as a character's skeleton; the dynamic variables are variable elements that need to be determined by the server, such as the character's hair color, the style and color of their clothing.

[0045] Step S103: If the judgment result of step S102 is yes, that is, evName contains both fixed variables and dynamic variables, then the system constructs the dynamic variables in evName using a linked list data structure. The linked list adopts a closed-loop structure, and its access mode is from one node to the next node until the last node points to the first node, forming a closed loop. This structure is used to organize dynamic variables with logical order or hierarchical relationship. For example, a linked list describing the character's clothing style (from head to toe) can be constructed, and another independent linked list can be constructed to describe the colors of these style components, thereby realizing variable management from general to detailed.

[0046] Step S104: The client combines the fixed variable with the dynamic variable linked list constructed in step S103 to form a complete variable structure, which associates the resource ID with the corresponding resource data.

[0047] Step S105: The client checks whether the variable structure generated in step S104 conforms to the predefined specifications.

[0048] Step S106: If the verification result of step S105 is yes, that is, the variable structure conforms to the specification, then proceed to step S2.

[0049] Step S107: If the verification result of step S105 is negative, that is, the variable structure does not conform to the specification; or, if the judgment result of step S102 is negative, that is, evName does not contain dynamic variables or the structure is incomplete, then the system performs a variable type reconfiguration operation.

[0050] Step S108: After completing the reconfiguration in step S107, the process returns to step S104, re-executes the combination operation of variables and resources, and continues the subsequent verification process.

[0051] Step S2: The server checks whether a pre-download variable resource corresponding to the resource fixed variable template exists locally. If it exists, proceed to step S3; otherwise, proceed to step S6.

[0052] Step S3: The server obtains the currently pre-downloaded variable resource file and verifies the integrity and version consistency of the resource file by calculating and comparing its HASH value. If the HASH value matches, it indicates that the pre-downloaded resource is valid, and then proceeds to step S9; if the HASH value does not match, it indicates that the resource may be corrupted or the version is outdated, and then proceeds to step S4.

[0053] Step S4: When pre-download resource verification fails or the server does not have pre-download resources, the client will request and generate a block of dynamic memory for the dynamic variable. It should be noted that the client will request dynamic memory for the dynamic variable regardless of whether it matches the server's pre-download resources. This is because updates to dynamic resources (such as real-time loading content in a game) are performed dynamically, and the allocation of dynamic memory ensures the flexibility and consistency of the resource loading process. Subsequently, the client fills the required latest resource data into this dynamic memory.

[0054] Step S5: The client maps (or demaps) the dynamically generated memory containing the data to persistent storage on disk. This step synchronizes the dynamic resource data in memory to disk.

[0055] Step S6: The client loads the dynamically mapped memory variables onto disk. Then, it refreshes the relevant resources on disk to make the newly loaded dynamic resources effective.

[0056] Step S9: If the HASH value comparison in step S3 matches, the client directly loads the valid resource that already exists in memory and has been mapped.

[0057] Please refer to Figure 3The present invention also provides a terminal 1, including a memory 3, a processor 2, and a computer program stored on the memory 3 and running on the processor 2. When the processor 2 executes the computer program, it implements the various steps in the above-described dynamic resource management method.

[0058] The beneficial effects of the terminal of the present invention are the same as those of the method described above, and will not be repeated here.

[0059] In summary, this invention provides a dynamic resource management method and terminal. By acquiring environment variable identifiers, the current operating environment or configuration is determined. At least one scenario variable corresponding to this identifier is identified, clarifying the specific set of resources that need to be dynamically loaded. A linked list structure is constructed for these scenario variables, and access link information is generated based on this structure. This step organizes discrete resources into an ordered, traversable loading sequence. Finally, the access link information is sent to the client, which then performs access operations sequentially, thereby loading resources on demand. Compared to existing technologies where PC clients rely on broadcast mechanisms and must restart the client to load the complete resource package, this invention solves the problems of cumbersome update processes and user experience interruptions. Existing solutions, during resource updates, cannot dynamically identify and load incremental or changed fragmented resources, requiring application restarts. This invention, by generating and sending structured access link information, guides the client to dynamically load resources corresponding to scenario variables in a specific order, achieving hot resource updates without requiring client restarts. This significantly reduces the number of client restarts caused by resource updates, improves the flexibility and efficiency of resource loading, optimizes the user experience, and simplifies the remote deployment process.

[0060] The above description is merely an embodiment of the present invention and does not limit the patent scope of the present invention. Any equivalent modifications made based on the content of the present invention specification and drawings, or direct or indirect applications in related technical fields, are similarly included within the patent protection scope of the present invention.

Claims

1. A dynamic resource management method, characterized in that, Applied to the server side, the method includes: Get environment variable identifiers; Determine at least one scenario variable corresponding to the environmental variable identifier; A linked list structure is constructed for the scene variables, and access link information of the scene variables is generated based on the linked list structure; The access link information is sent to the client so that the client can perform access operations sequentially according to the access link information.

2. The dynamic resource management method according to claim 1, characterized in that, The step of constructing a linked list structure for the scenario variables includes: Construct a doubly linked list or a closed-loop linked list for the scenario variables.

3. The dynamic resource management method according to claim 1, characterized in that, The determination of at least one scene variable corresponding to the environment variable identifier includes: Based on the environment variable identifier, set multiple scene variables that match the environment variable identifier, wherein the scene variables include resource identifiers.

4. The dynamic resource management method according to claim 1, characterized in that, The step of generating the access link information of the scene variables based on the linked list structure includes: Based on the linked list structure, access link information for the scene variables is generated, and the access link information includes placeholders with a predetermined format corresponding to the nodes of the linked list structure.

5. The dynamic resource management method according to claim 1, characterized in that, Also includes: Set fixed and dynamic variables in the scene variables; A linked list structure is constructed for the dynamic variables. The linked list structure includes linked list nodes, and each linked list node contains a resource identifier and its corresponding resource data.

6. A dynamic resource management method, characterized in that, Applied to a client, the method includes: Retrieve predefined resource fixed variable templates; Receive access link information from the server; Based on the access link information, determine the dynamic variables to be loaded and their corresponding target resource identifiers; Allocate dynamic memory for the dynamic variable to be loaded, and load the corresponding resource data into the dynamic memory according to the target resource identifier.

7. The dynamic resource management method according to claim 6, characterized in that, Based on the access link information, determine the dynamic variables to be loaded and their corresponding target resource identifiers, including: Determine if there are any dynamic variables to be loaded. If so, obtain the target resource identifier and resource data corresponding to the dynamic variables to be loaded.

8. The dynamic resource management method according to claim 6, characterized in that, The step of loading the corresponding resource data according to the target resource identifier includes: Compare the resource data corresponding to the target resource identifier with the hash value of the existing local resources; If the comparison is inconsistent, the resource data from the server will be filled into the dynamic memory allocated by the dynamic variable. If the comparison is consistent, the resource data already mapped in memory is loaded directly.

9. The dynamic resource management method according to claim 6, characterized in that, The receipt of access link information from the server includes: Receive access link information and resource data corresponding to the resource identifier in the access link information.

10. A terminal comprising a memory and a processor, the memory storing a computer program, characterized in that, When the processor executes the computer program, it implements the dynamic resource management method according to any one of claims 1 to 5 or the dynamic resource management method according to any one of claims 6 to 9.

Images