Cooperative control method and system for dynamically intervening large file uploading

Abstract

The invention provides a cooperative control method and system for dynamically intervening large file uploading, and the system comprises a dynamic task state machine, a resource allocation arbiter, and a user interaction module which is connected with the dynamic task state machine and is used for receiving an instruction and displaying a state, and based on the fragment state and progress information maintained in the dynamic task state machine, the global uploading progress and file uploading execution module is used for being connected with the resource allocation arbiter and executing network transmission. According to the system, a dynamic task state machine and a resource allocation arbiter are introduced to serve as a dual-core control center, the dynamic task state machine ensures that the global state is consistent, the resource allocation arbiter realizes intelligent scheduling and accurate speed limiting of network resources, and the problem that after an existing fragment uploading technology is combined, the network resources cannot be intelligently scheduled and accurately limited is solved. And collaborative contradictions such as state management confusion, progress calculation distortion and resource scheduling conflicts under real-time intervention of the user are solved.

Description

Technical Field

[0001] This invention belongs to the technical field of Web front-end engineering and computer network application, and more specifically, relates to a collaborative control method and system for dynamic and controllable large file uploads. Background Technology

[0002] As web applications become increasingly complex, large file uploads have become a common requirement. Existing technologies typically employ methods such as chunked uploads, resumable uploads, and concurrency control to optimize transmission. However, when these technologies are simply layered together, and users are allowed to dynamically intervene in real-time during transmission, such as pausing, resuming, adjusting speed, and retrying, the system exposes the following deep-seated coordination contradictions that existing technologies have failed to adequately address: State synchronization conflict: A user intervention command (such as pause) needs to be applied to multiple concurrently uploading fragment threads. Traditional solutions struggle to achieve atomic and consistent updates of all fragment states, often resulting in command response delays and inconsistencies between the UI state and the actual transmission state.

[0003] Inconsistent progress calculation: In non-linear transmission processes such as dynamic start-stop, retrying after fragment failure, and user-initiated speed adjustment, the simple "uploaded bytes / total bytes" calculation model cannot accurately reflect the actual remaining workload, resulting in progress bar stagnation, bounce, or severely inaccurate estimated time, leading to a poor user experience.

[0004] Resource scheduling conflicts arise because there is a lack of a unified coordination mechanism between user-defined global speed limits, system-imposed concurrency controls for efficiency improvements, and the actual carrying capacity of the browser's underlying infrastructure and the network. This can easily lead to speed-limiting commands becoming indirectly ineffective due to excessive concurrency, or concurrency control becoming idle due to speed limits, resulting in resource waste. Summary of the Invention

[0005] This invention addresses the technical problems existing in the prior art by providing a collaborative control method and system for dynamically controllable large file uploads. The purpose of this invention is to overcome the aforementioned collaborative contradictions and provide a front-end intelligent upload control system that can uniformly coordinate task status, accurately calculate progress, and intelligently schedule resources.

[0006] According to a first aspect of the present invention, a collaborative control method for dynamically controllable large file uploads is provided, comprising the following steps: Construct a dynamic task state machine as the central hub of the system state to uniformly manage the state of files and all their fragments; Construct a resource allocation arbitrator as the central hub for system resource scheduling, which is used to make upload decisions based on a comprehensive consideration of user settings, system policies, and real-time network conditions; Receive real-time control commands generated by users or the system; The dynamic task state machine responds to the instruction by atomically updating the state of all affected fragments and issuing a scheduling event to the resource allocation arbitrator; The resource allocation arbitrator performs resource allocation operations, including starting, stopping, delaying, or adjusting priorities, based on the scheduling event. Based on the fragmentation status and progress information maintained in the dynamic task state machine, the global upload progress is aggregated, calculated, and updated.

[0007] Based on the above technical solution, the present invention can also be improved as follows.

[0008] Optionally, the real-time control commands include one or more of the following: start uploading, pause uploading, continue uploading, retry uploading, delete uploading task, and set uploading speed limit.

[0009] Optionally, the dynamic task state machine, used for unified management of the state of files and all their fragments, includes: Atomized state transition: Receives any internal or external event and drives all affected task units to synchronously transition in a transactional manner, ensuring the consistency of the system's global state view; Progress baseline management: During state transitions, freeze or record the precise progress of the current shard as the sole reliable source for subsequent aggregation calculations; Persistent coordination: Interacts with local storage to save and restore the context of upload sessions.

[0010] Optionally, the resource allocation arbitrator is used to make upload decisions by comprehensively considering user settings, system policies, and real-time network conditions, including: Multi-strategy arbitration: Based on a configurable arbitration strategy model, it comprehensively evaluates multiple dimensions such as "user speed limit", "system maximum concurrency", "current measured network speed" and "task priority". Dynamic traffic shaping: By precisely calculating and inserting delays, the rate at which tasks are retrieved from the queue is controlled, thereby achieving smooth control of uplink bandwidth at the application layer and ensuring that user-defined thresholds are not exceeded. Request lifecycle control: Based on state machine instructions, network request cancellation tokens are created or destroyed directly, enabling real-time start and stop control of transmission links.

[0011] Optionally, when the resource allocation arbitrator performs resource allocation, it executes closed-loop speed control, including: Monitor real-time upload speed, compare the real-time upload speed with the speed limit set by the user, and dynamically adjust the task dispatch delay based on the comparison result to achieve traffic shaping at the application layer.

[0012] Optionally, when the instruction is to pause or delete, the steps of the resource allocation arbitrator performing the resource allocation operation include: generating and invoking a cancellation token corresponding to the network request to suspend the ongoing network transmission.

[0013] Optionally, the method further includes resuming interrupted downloads, wherein resuming interrupted downloads includes: During task initialization, the dynamic task state machine loads and verifies the validity period of locally persisted historical states. For valid historical states, only incomplete fragments are submitted to the resource allocation arbitrator. For expired historical states, a cleanup process is triggered on both the local and server sides before a new upload is initiated.

[0014] Optionally, when the scheduling event is transmission speed control, the resource allocation arbitrator, based on the built-in speed metering unit, samples the total number of bytes transmitted by all active upload requests in a fixed time window, calculates the instantaneous speed and deviation, compares the calculated instantaneous speed with the target speed limit set by the user, and obtains the speed deviation. If the instantaneous speed is lower than the limit, the arbitrator will dispatch new fragment tasks from the upload queue normally or at an accelerated speed. If the instantaneous speed reaches or exceeds the limit, the arbitrator starts the delayed scheduling algorithm and dynamically calculates the waiting time that needs to be inserted before the next task is dispatched, based on the proportion of the excess.

[0015] Optionally, in the process of aggregating and updating the global upload progress based on the shard status and progress information maintained in the dynamic task state machine, the progress calculation obtains authoritative data from the dynamic task state machine. When an event that causes a change in the shard status or frozen progress is encountered, the dynamic task state machine is triggered to re-aggregate and calculate.

[0016] According to a second aspect of the present invention, a collaborative control system for dynamically controllable large file uploads is provided, comprising: The dynamic task state machine is configured as the state hub of the system and responds to real-time control commands, atomically updating the state of all affected fragments and issuing scheduling events to the resource allocation arbitrator. The resource allocation arbitrator is configured as the resource scheduling hub of the system and performs resource allocation operations, including starting, stopping, delaying or prioritizing, based on the scheduling events. The user interaction module is connected to the dynamic task state machine and is used to receive instructions and display status. Based on the fragmented status and progress information maintained in the dynamic task state machine, it aggregates, calculates and updates the global upload progress. The file upload execution module is connected to the resource allocation arbitrator and is used to perform network transmission.

[0017] Compared with the prior art, the present invention has the following beneficial effects: This invention provides a collaborative control method and system for dynamically manageable large file uploads. By introducing a dynamic task state machine and a resource allocation arbitrator as dual-core control hubs, it resolves collaborative issues such as chaotic state management, distorted progress calculations, and resource scheduling conflicts that arise when existing fragmented upload technologies are combined and subjected to real-time user intervention. The dynamic task state machine ensures global state consistency, while the resource allocation arbitrator enables intelligent scheduling and precise rate limiting of network resources. This invention significantly improves the reliability, user experience, and network resource utilization efficiency of large file uploads in complex interactive scenarios.

[0018] Other features and advantages of the invention will be set forth in the description which follows, and will be apparent in part from the description, or may be learned by practicing the invention. The objects and other advantages of the invention may be realized and obtained by means of the structures pointed out in the description, claims and drawings. Attached Figure Description

[0019] Figure 1 This is a flowchart of a collaborative control method for dynamically controllable large file uploads, provided as an embodiment of the present invention. Detailed Implementation

[0020] 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 embodiments of the present invention, and not all embodiments. 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.

[0021] Understandably, given the deficiencies in the background technology, this invention proposes a collaborative control method for dynamically controllable large file uploads, specifically as follows: Figure 1 As shown, it includes the following steps: Step S1: Construct a dynamic task state machine as the central hub of the system state to uniformly manage the state of files and all their fragments; Step S2: Construct a resource allocation arbitrator as the central hub for system resource scheduling, which is used to make upload decisions based on user settings, system policies, and real-time network conditions; Step S3: Receive real-time control commands generated by the user or the system; the real-time control commands include at least one or more of the following: start uploading, pause uploading, continue uploading, retry uploading, delete uploading task, and set uploading speed limit; Step S4: In response to the instruction, the dynamic task state machine atomically updates the state of all affected fragments and sends a scheduling event to the resource allocation arbitrator. Step S5: The resource allocation arbitrator performs resource allocation operations, including starting, stopping, delaying, or adjusting priorities, based on the scheduling event. Step S6: Based on the fragmentation status and progress information maintained in the dynamic task state machine, aggregate, calculate, and update the global upload progress.

[0022] In summary, this invention introduces a dynamic task state machine and a resource allocation arbitrator as dual-core control hubs. The dynamic task state machine ensures strong consistency of the global state, while the resource allocation arbitrator enables intelligent scheduling and precise rate limiting of network resources. This solves the coordination contradictions such as chaotic state management, distorted progress calculation, and resource scheduling conflicts that occur when users intervene in real time after combining existing fragmented upload technologies.

[0023] It should be noted that the dynamic task state machine is the only authoritative state management center within the system. It maintains a clear state for each uploaded file and each fragment (e.g., initialization, pending upload, uploading, paused, waiting for retry, completed, failed).

[0024] The responsibilities of the dynamic task state machine include: Atomized state transitions: Receive any internal or external events and drive all affected task units to synchronize state transitions in a transactional manner, ensuring the consistency of the system's global state view.

[0025] Progress baseline management: When the state transitions (such as switching to "paused"), freeze or record the precise progress of the current shard as the sole reliable source for subsequent aggregation calculations.

[0026] Persistent coordination: Interacts with local storage to save and restore the context of the upload session, and is the decision-maker for breakpoint resume logic.

[0027] It should be noted that the resource allocation arbitrator is an intelligent scheduling center for system resources. It treats network requests as applications for "bandwidth" and "connection count" resources.

[0028] The responsibilities of the resource allocation arbitrator include: Multi-strategy arbitration: Based on a configurable arbitration strategy model, it comprehensively evaluates multiple dimensions such as "user speed limit", "maximum system concurrency", "current measured network speed" and "task priority".

[0029] Dynamic traffic shaping: By precisely calculating and inserting latency, the rate at which tasks are retrieved from the queue is controlled, thereby achieving smooth control of uplink bandwidth at the application layer and ensuring that user-defined thresholds are not exceeded.

[0030] Request lifecycle control: Based on state machine instructions, network request cancellation tokens are created or destroyed directly, enabling real-time start and stop control of transmission links.

[0031] When the resource allocation arbitrator performs resource allocation, it executes closed-loop speed control, including: monitoring the real-time upload speed, comparing the real-time upload speed with the speed limit set by the user, and dynamically adjusting the task dispatch delay based on the comparison result, so as to achieve traffic shaping at the application layer.

[0032] The example is as follows: When the user-generated command is "pause", the collaborative workflow between the dynamic task state machine and the resource allocation arbitrator includes the following steps: Event triggered: The user clicks the "pause" button on a file.

[0033] Dynamic task state machine response: The dynamic task state machine receives a "pause" command.

[0034] Execute the following instructions immediately: Mark the target status of all segments in the file that are in the "Uploading" state as "Paused".

[0035] Send a batch "pause arbitration" event to the resource allocation arbitrator, along with a list of relevant shards.

[0036] (State consistency guarantee) During this period, any new upload completion or progress callback events related to these fragments must be queued and wait for the state transition to complete.

[0037] The resource allocation arbitrator performs the following operations: Upon receiving an event, the resource allocation arbitrator immediately freezes or removes the corresponding shard task from the upload queue, calls the cancellation token corresponding to each relevant shard network request, forcibly terminates the HTTP connection, and sends a "resource released" signal to the dynamic task state machine.

[0038] Status Confirmation and Update: After receiving feedback from the resource allocation arbitrator, the dynamic task state machine updates the status of all "paused" shards to "paused". It records and freezes the upload progress of each shard when it is aborted.

[0039] The progress calculation module is triggered, and based on the latest frozen progress of all segments, the global progress of the file is re-aggregated and generated.

[0040] UI Update: The progress calculation module sends a new global progress notification to the Vue component, and the progress bar on the screen immediately stops and stabilizes at the accurate position.

[0041] When the instruction is to pause or delete, the steps for the resource allocation arbitrator to perform the resource allocation operation include: Generate and invoke the cancellation token for the corresponding network request to abort the ongoing network transmission.

[0042] The collaborative control method further includes a breakpoint resumption step, which includes: During task initialization, the dynamic task state machine loads and verifies the validity period of locally persisted historical states. For valid historical states, only incomplete fragments are submitted to the resource allocation arbitrator. For expired historical states, a cleanup process is triggered on both the local and server sides before a new upload is initiated.

[0043] The implementation steps involved in this invention will be further described in detail below, combining the system architecture and core processes. Specifically, as follows... Figure 1 As shown, the implementation steps include the following: Part 1: File Addition and Task Initialization Process; File HASH Generation: After a user adds a file, the system uses the SparkMD5 algorithm in the background to calculate the file content and generate a unique file fingerprint (HASH value). This HASH is the sole basis for all subsequent status identification, breakpoint resume, and server file merging.

[0044] Shard metadata creation: Based on the preset shard size (e.g., 2MB), the file sharding module logically divides the large file into N ordered chunks and generates a metadata object for each chunk containing information such as index, size, and starting offset. At this stage, no actual binary data splitting is performed.

[0045] State machine initialization: The dynamic task state machine creates a new task control block based on the file hash and the fragment metadata list. It first queries the local persistent storage to check for the existence of unexpired historical states.

[0046] Arbitrator Registration: The state machine synchronizes the newly created task control block information to the resource allocation arbitrator, which assigns an initial priority to the task and prepares to receive scheduling requests.

[0047] Resume upload decision: If a valid historical state exists, the state machine loads the index list of uploaded fragments from local storage and initializes the corresponding fragment state to "completed". Subsequently, only incomplete fragments are marked as "pending upload", and this list is submitted to the arbitrator for queuing.

[0048] If there is no historical status, mark all fragments as "pending upload" and submit.

[0049] 2. Transmission speed control; The resource allocation arbitrator achieves precise speed limiting through a closed-loop feedback control system.

[0050] Speed ​​monitoring: The arbitrator has a built-in speed metering unit that samples the total number of bytes transmitted by all active upload requests at fixed time windows (e.g., 500 milliseconds) to calculate the instantaneous speed.

[0051] Deviation calculation: The calculated instantaneous speed is compared with the target speed limit set by the user to obtain the speed deviation.

[0052] Adjustment Decision: If the instantaneous speed is below the limit, the arbitrator dispatches new task fragments from the upload queue normally or at an accelerated pace. If the instantaneous speed reaches or exceeds the limit, the arbitrator will activate a delayed scheduling algorithm. This algorithm dynamically calculates the delay to be inserted before the next task is dispatched based on the percentage of the speed exceeding the limit. For example, when the speed exceeds the limit by 10%, a 100-millisecond delay may be inserted. This dynamic delay achieves a "token bucket" style traffic shaping effect.

[0053] Queue Management: All fragmented tasks awaiting upload are not simply stored in a first-in, first-out queue. The arbitrator can dynamically sort the queue based on factors such as task priority and fragment sequence number, ensuring optimized transmission order even under rate limiting conditions.

[0054] Three: Schedule Calculation; The progress calculation in this invention is handled by a progress calculation module, the core of which is to obtain an authoritative data source from the dynamic task state machine, rather than directly accumulating network callback events.

[0055] Data source: The progress calculation module listens to the state of each slice in the state machine and the "freeze progress" attribute.

[0056] Aggregation model: Shard progress: The progress of a shard = (its "frozen progress" or "last reported progress") * the weight of the shard size relative to the total file size.

[0057] Total file progress: Total progress = Σ (progress of each segment). For segments with a status of "Completed", their progress weight is 100%; "Pending upload" is 0%; "Uploading" or "Paused" are their frozen progress values.

[0058] Update Trigger: Any event that changes the fragment status or frozen progress (e.g., fragment upload complete, user pause, fragment upload progress callback) will trigger the state machine to notify the progress calculation module to perform a re-aggregation calculation. This model ensures that even in non-linear, frequently interrupted scenarios, the progress display remains linear, accurate, and non-backtracking.

[0059] 4. Resuming interrupted downloads and clearing state; Status validity period management: For each persistent operation performed locally by the dynamic task state machine (such as when a certain segment upload is completed), a "last update timestamp" will be updated in the storage record.

[0060] Before attempting to resume the upload, the status function checks the difference between the current time and the "last update timestamp". If the difference exceeds a preset validity period (e.g., 24 hours), the status is determined to have expired.

[0061] Expiration status handling: The state machine actively clears expired state records locally.

[0062] At the same time, a "cleanup command" is sent to the server through the upload core module, requesting the server to delete all temporary fragment files associated with the hash of this file.

[0063] Afterward, the system treats the file as a completely new file and initiates a new upload process. This mechanism avoids unnecessary storage space usage and the problem of dirty data.

[0064] Compared to the simple combination solutions of existing technologies, the beneficial effects of this invention include: Improved control precision and reliability: The "dynamic task state machine" enables strong consistency management of multi-task states under complex interactions, reduces user command response latency, and significantly enhances the predictability of system behavior.

[0065] Significantly improved user experience: The progress calculation model based on authoritative status sources completely solves the problem of progress bar distortion under dynamic intervention, providing accurate, smooth, and reliable progress feedback.

[0066] Intelligent utilization of network resources: The "resource allocation arbitrator" achieves a balance between user wishes, system efficiency, and network conditions. It can strictly respect users' speed limit settings while making full use of idle network bandwidth, thus avoiding resource contention and internal friction.

[0067] Enhanced system robustness and maintainability: The dual-core architecture clearly defines responsibilities, decoupling state logic, scheduling logic, and business logic. The system boasts strong scalability (e.g., allowing for the addition of new intervention command types) and facilitates debugging and problem tracking.

[0068] Deeply integrated with the front-end framework ecosystem: The control core is implemented with pure JavaScript logic, perfectly complementing Vue.js's reactive system. The state machine, as the sole source of truth, directly drives Vue component updates, resulting in an elegant and efficient architecture.

[0069] According to a second aspect of the present invention, a collaborative control system for dynamically controllable large file uploads is provided, comprising: The dynamic task state machine is configured as the state hub of the system and responds to real-time control commands, atomically updating the state of all affected fragments and issuing scheduling events to the resource allocation arbitrator. The resource allocation arbitrator is configured as the resource scheduling hub of the system and performs resource allocation operations, including starting, stopping, delaying or prioritizing, based on the scheduling events. The user interaction module is connected to the dynamic task state machine and is used to receive instructions and display status. Based on the fragmented status and progress information maintained in the dynamic task state machine, it aggregates, calculates and updates the global upload progress. The file upload execution module is connected to the resource allocation arbitrator and is used to perform network transmission.

[0070] It is understood that the collaborative control system for dynamically controllable large file uploads provided by this invention corresponds to the collaborative control method for dynamically controllable large file uploads provided in the foregoing embodiments. The relevant technical features of the collaborative control system for dynamically controllable large file uploads can be referred to the relevant technical features of the collaborative control method for dynamically controllable large file uploads, and will not be repeated here.

[0071] It should be noted that this embodiment of the invention proposes an intelligent collaborative system with a "dynamic task state machine" and a "resource allocation arbitrator" as its dual core control hubs. This system abstracts user intervention, network events, and task status into unified state events, and treats all resources (network bandwidth, number of connections) as arbitrable competitive resources. Through core control logic, it achieves orderly, precise, and efficient control in complex scenarios. The system is suitable for front-end file transfer applications that require high reliability, strong interactivity, and resource friendliness in complex network environments.

[0072] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.

[0073] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments.

[0074] Although preferred embodiments of the invention have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including both the preferred embodiments and all changes and modifications falling within the scope of the invention.

[0075] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.

[0076] Finally, it should be noted that the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing embodiments or make equivalent substitutions for some of the technical features. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A collaborative control method for dynamic intervenable large file upload, characterized in that, The method comprises the following steps: constructing a dynamic task state machine as a system state hub for unified management of the states of a file and all its shards; constructing a resource allocation arbitrator as a system resource scheduling hub for making upload decisions based on user settings, system policies, and real-time network conditions; receiving real-time control instructions generated by a user or the system; the dynamic task state machine atomically updating the states of all affected shards in response to the instructions and issuing scheduling events to the resource allocation arbitrator; the resource allocation arbitrator performing resource allocation operations including starting, stopping, delaying, or adjusting priorities based on the scheduling events; based on the shard states and progress information maintained in the dynamic task state machine, aggregating calculations and updating the global upload progress.

2. The collaborative control method for dynamic intervenable large file uploading according to claim 1, wherein, The real-time control instructions include one or more of starting an upload, pausing an upload, continuing an upload, retrying an upload, deleting an upload task, and setting an upload speed limit.

3. The collaborative control method for dynamic intervenable large file uploading according to claim 1, wherein, The dynamic task state machine for unified management of the states of a file and all its shards includes: atomic state transition: receiving any internal or external events and driving all affected task units to undergo state transitions in a transactional manner to ensure consistency of the system global state view; progress benchmark management: freezing or recording the exact progress of a shard at the time of state transition as the only trusted source for subsequent aggregated calculations; persistent coordination: interacting with a local storage to save and restore the context of an upload session.

4. The collaborative control method for dynamic intervenable large file uploading according to claim 1, wherein, The resource allocation arbitrator for making upload decisions based on user settings, system policies, and real-time network conditions includes: multi-policy arbitration: comprehensively judging multiple dimensions including user speed limits, system maximum concurrency, current measured network speed, and task priorities according to a configurable arbitration policy model; dynamic traffic shaping: controlling the rate at which tasks are taken out of a queue by precise calculations and insertion of delays to achieve smooth control of uplink bandwidth at the application layer, ensuring that user-set thresholds are not exceeded; request lifecycle control: directly creating or destroying cancellation tokens for network requests according to state machine instructions to achieve immediate start-stop control of transmission links.

5. The collaborative control method for dynamic intervenable large file uploading according to claim 1, wherein, When the resource allocation arbitrator performs resource allocation, it performs closed-loop speed control, including: monitoring real-time upload speed, comparing the real-time upload speed with user-set speed limits, and dynamically adjusting task dispatching delays based on the comparison results to achieve application-layer traffic shaping.

6. The collaborative control method for dynamic intervenable large file uploading according to claim 5, wherein, When the instructions are to pause or delete, the steps performed by the resource allocation arbitrator to perform resource allocation operations include: generating and invoking cancellation tokens for corresponding network requests to abort ongoing network transmissions.

7. The collaborative control method for dynamic intervenable large file uploading according to claim 1, wherein, The method further includes resuming interrupted uploads, which includes: the dynamic task state machine loading and verifying the validity period of a locally persisted historical state at task initialization, submitting only incomplete shards to the resource allocation arbitrator for a valid historical state, and triggering local and server-side cleanup processes before starting a completely new upload for an expired historical state.

8. The collaborative control method for dynamic intervenable large file uploading according to claim 1, wherein, When the scheduling event is transmission speed control, the resource allocation arbitrator samples the total number of bytes transmitted by all active upload requests in a fixed time window according to an internal speed metering unit, calculates the instantaneous speed and deviation, compares the calculated instantaneous speed with the target speed limit set by the user, and obtains the speed deviation; If the instantaneous speed is lower than the limit, the arbitrator normally or accelerates to dispatch new shard tasks from the upload queue; If the instantaneous speed reaches or exceeds the limit, the arbitrator starts the delay scheduling algorithm, dynamically calculates the waiting time to be inserted before the next task dispatching according to the exceeded proportion.

9. The collaborative control method for dynamic intervenable large file uploading according to claim 1, wherein, The global upload progress is aggregated, calculated and updated based on the shard state and progress information maintained in the dynamic task state machine. The progress calculation obtains the authoritative data source from the dynamic task state machine. When an event that causes the shard state or frozen progress to change is encountered, the dynamic task state machine is triggered to perform re-aggregation calculation.

10. A collaborative control system oriented to dynamic intervenable large file upload, characterized in that, It includes: A dynamic task state machine configured as the state hub of the system and responding to real-time control instructions, atomically updating the state of all affected shards and issuing scheduling events to the resource allocation arbitrator; A resource allocation arbitrator configured as the resource scheduling hub of the system, performing resource allocation operations including starting, stopping, delaying or priority adjusting according to the scheduling events; A user interaction module connected to the dynamic task state machine for receiving instructions and displaying states, and aggregating, calculating and updating the global upload progress based on the shard state and progress information maintained in the dynamic task state machine; A file upload execution module connected to the resource allocation arbitrator for performing network transmission.

Images