Clock drift prevention and high concurrency flight simulation data acquisition method and system

Abstract

The application belongs to the technical field of computer software and virtual simulation, and relates to a flight simulation data acquisition method and system capable of preventing clock drift and high concurrency; the method is used for solving the problems of data time sequence disorder and monitoring blind area in large-scale concurrent experiments, adopts a passive and active hybrid reporting mechanism capable of preventing clock drift, forcibly strips local time stamps when a client triggers a physical anchor to actively report progress JSON data, and unifies time distribution by a server, and simultaneously cooperates with a message queue to issue instructions to realize passive polling of instantaneous progress; in addition, online student identifiers are stored by using a Redis-based set data structure, traditional database lock table updating is abandoned, and microsecond-level online number lock-free statistics are realized; the application guarantees consistency of experimental data, overcomes defects such as calculation blocking and high-concurrency lock competition, and improves concurrent bearing capacity and rendering fidelity of the system.

Description

Technical Field

[0001] This invention belongs to the field of computer software and virtual simulation technology, specifically relating to a method and system for flight simulation data acquisition that prevents clock drift and enables high concurrency. Background Technology

[0002] The rapid development of information technology in flight training has made aerodynamics and flight mechanics virtual simulation systems an important teaching tool. However, existing distributed simulation system architectures still have the following technical shortcomings in large-scale concurrent experimental scenarios: I. Complex algorithms cause server-side computational blocking. Solving high-order differential equations requires calling engines such as Matlab, and the computation time is uncertain. Existing synchronous or simple asynchronous mechanisms are prone to Servlet thread exhaustion when multiple students are solving concurrently, reducing system throughput and stability.

[0003] Second, client clock drift causes data inconsistency. Current data reporting relies on the client's local timestamp, but errors exist between client clocks, which can easily disrupt data sequence and anti-fraud mechanisms. Furthermore, single proactive reporting creates monitoring blind spots when anchor points are not triggered for extended periods, while global polling significantly increases redundant communication, burdening network bandwidth and server load.

[0004] Third, under high concurrency (the system's ability to process a large number of requests simultaneously), online state synchronization suffers from lock contention bottlenecks. Traditional relational databases maintain online user tables, and frequent state changes trigger dense lock contention and I / O bottlenecks, making it difficult to achieve low-latency real-time tracking.

[0005] In view of this, it is very necessary to provide a method and system for flight simulation data acquisition that prevents clock drift and enables high concurrency, so as to solve the above-mentioned defects in the prior art. Summary of the Invention

[0006] The purpose of this invention is to address the shortcomings of the existing technology, such as server-side computational blocking, data timing disorder, monitoring blind spots, and high-concurrency lock contention, by providing a flight simulation data acquisition method and system that prevents clock drift and enables high concurrency, thereby solving the aforementioned technical problems.

[0007] To achieve the above objectives, the present invention provides the following technical solution: A method for acquiring flight simulation data to prevent clock drift and handle high concurrency includes the following steps: Step S1: The server uses a distributed unified authentication and gateway authentication scheme based on JWT (JSON Web Token) to complete the unified identity authentication of the client. After successful authentication, the client loads the 3D flight simulation experiment scene. Step S2: The client runs a flight simulation experiment and sets multiple state anchor points in the physical phase of the flight simulation experiment. During the flight simulation experiment, when the preset state anchor point is triggered, the client performs a clock-independent active reporting and reports the experiment progress data to the server. When the server detects that the client has not triggered a new state anchor point within a preset threshold time, it sends a passive reporting instruction to the client through a message queue. The client responds to the instruction and performs passive reporting based on message polling, reporting the experimental progress data to the server. Step S3: The server receives the experiment progress data, assigns a globally unified system timestamp to the experiment progress data, and stores the experiment progress data. Step S4: Based on the lock-free online user statistics logic of Redis (RemoteDictionaryServer), obtain the current online user count of the flight simulation experiment in real time; Step S5: If the flight simulation experiment performed by the client involves solving complex aerodynamic or flight mechanics equations, then an asynchronous solution mechanism is executed.

[0008] Preferably, step S1 specifically includes: In step S11, the client initiates a login request through the unified authentication service, and the server verifies the client user's identity. Step S12: After the server-side authentication service verifies the legitimacy of the client user's identity, it generates a JWT token containing the user's identity and permission information. Step S13: The client initiates a business access to the microservice gateway carrying a JWT token; Step S14: The microservice gateway parses and verifies the JWT token; Step S15: After successful verification, append the parsed plaintext information to the Header of the original request and dynamically route it to the experimental business microservice. Step S16: The client receives the response forwarded by the microservice gateway and loads the 3D flight simulation experiment scene.

[0009] Preferably, in step S2, the client performs clock-independent active reporting, reporting the experimental progress data to the server, specifically including: The client proactively encapsulates the experiment progress data into a JSON format data packet and reports it. During the encapsulation process, the client actively removes the time node information of the local device to avoid data inconsistency caused by inaccurate clocks on the student's end.

[0010] Preferably, in step S2, the client responds to the instruction and performs passive reporting based on message polling to report the experimental progress data to the server, specifically including: The client receives a query command from the server, is passively woken up, immediately collects the current instantaneous experimental progress data, encapsulates the collected experimental progress data into a JSON data packet, and reports it to the server.

[0011] Preferably, the JSON format data packet actively reported by the client in step S2 has a data message structure that includes at least: a type field (type) identifying the reporting type, a project number (projID), an experiment number (experimentID), and a progress percentage (progress).

[0012] Preferably, the lock-free online user counting logic based on Redis sets in step S4 specifically includes: When the server receives the experiment progress data reported by the client, it represents the student entering the flight simulation experiment, extracts the student ID (Identifier) ​​from the client, and directly stores it in a set with the current "experiment ID" as the key. When a student exits normally, switches experiments, or the heartbeat times out, the corresponding student ID is removed from the set using the Redis Remove command. When an instructor requests the current real-time number of online participants for a flight simulation experiment, the number of elements in the experiment's Set can be read to obtain the current number of online participants in microseconds, replacing the traditional full table scan of the database and improving statistical efficiency and system response speed in concurrent scenarios. When the data in the set changes, such as when a student enters or exits an experiment, or when a heartbeat timeout triggers removal, the final statistical data is asynchronously synchronized to the integrated dashboard platform, reducing database I / O load.

[0013] Preferably, the asynchronous solution mechanism in step S5 specifically includes: After receiving the client's calculation request, the server generates a universally unique identifier (UUID), releases the current container thread, and generates an asynchronous result object (DeferredResult) to enter a blocking listening state. The simulation parameters with the universally unique identifier are pushed to the message queue. The independent core calculation engine node extracts the simulation parameters from the message queue and performs the calculation to obtain the calculation result. The calculation result message with the same universally unique identifier is pushed back to the message queue. The microservice listens for and obtains the calculation result message, matches the corresponding asynchronous result object according to the universally unique identifier, activates the asynchronous result object and re-requests a container thread, and responds to the client with the final calculation result data in JSON format, driving the 3D engine to perform real-time rendering of the aircraft's attitude.

[0014] Preferably, the asynchronous solution mechanism in step S5 also includes a timeout handling mechanism: after generating the asynchronous result object (DeferredResult), the server binds the asynchronous result object with the corresponding universal unique identifier and stores it in the cache, and sets a timeout period; if the corresponding solution result message is not received within the timeout period, the asynchronous result object is automatically released after the timeout and a solution timeout prompt message is returned to the client.

[0015] Furthermore, this invention also provides a flight simulation data acquisition system that prevents clock drift and enables high concurrency, comprising: The client simulation module is built using a cross-platform 3D engine and includes a management terminal for instructors and an operation terminal for students, which is used to provide interactive three-dimensional visualization of flight mechanics and aerodynamics. The microservice gateway and authentication module is deployed in the cloud and provides a unified microservice gateway entry point, dynamic routing and forwarding, and stateless identity authentication. The business processing and state synchronization module is built using a microservice architecture and is used to handle virtual simulation experiment logic, receive client data reports, and issue scheduling instructions. The distributed cache computing module is built with an in-memory database and its built-in collection data structure for lock-free calculation of online status and number of users under high concurrency. The asynchronous message-driven module is built using a message queue component and connects the business processing and state synchronization module and the client simulation module. It is used by the server to send passive reporting instructions to the client.

[0016] The beneficial effects of this invention are that it can eliminate the client clock trust crisis and ensure data consistency: it breaks the conventional path of client packaging timestamp reporting in traditional distributed systems, and by forcibly stripping the client's local time node information in the JSON data encapsulation stage, it assigns all time series calibration to the server, thereby eliminating the possibility of students tampering with the local system clock to forge the duration of the experiment or cheat, and ensuring the rigor and global consistency of scientific research and teaching experimental data. It can build a hybrid monitoring network that balances low network load and all-day coverage: the hybrid mechanism of "physical anchor point triggered active reporting" and "message queue command-based passive wake-up" enables the system to generate network communication only when there is a substantial leap in the experimental state during the normal experimental phase, reducing the high bandwidth cost caused by continuous polling; during blind spots when instructors need to check or students' progress is stagnant, the high-concurrency, low-latency message queue channel is used to realize the instantaneous passive reporting command issuance, achieving accurate monitoring of the experimental progress without blind spots at all times; Breaking through the bottleneck of relational databases, high-performance online concurrency management was achieved: Addressing the database table locking problem caused by thousands of users simultaneously switching experiments on a large teaching platform, the traditional relational database's table-scanning mode of maintaining online status through COUNT statistics and UPDATE updates was abandoned. Instead, the collection data structure characteristics of Redis caching were utilized to transform complex online status tracking into simple collection element addition (Add), removal (Remove), and cardinality counting (Card). This not only prevented duplicate student ID counting but also compressed the concurrent statistics time from hundreds of milliseconds in relational databases to microseconds. Decoupling complex computing power to avoid microservice crashes: To address the uncontrollable time consumption issues of complex matrix operations and differential equation solutions in flight mechanics and aerodynamics, the asynchronous suspension mechanism of the DeferredResult object is combined with a message queue. Computationally intensive tasks are offloaded to independent Matlab computing nodes, and the Web container thread is released in a timely manner before the results are returned. This ensures that the microservice gateway and core business system maintain throughput and stability under high concurrency requests, and avoids the exhaustion of global resources due to slow calculation of a single experiment.

[0017] Furthermore, the design principle of this invention is reliable, the structure is simple, and it has a very wide range of application prospects. Attached Figure Description

[0018] 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 embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0019] Figure 1 This is a flowchart of a flight simulation data acquisition method for preventing clock drift and achieving high concurrency, provided by the present invention.

[0020] Figure 2 This is a schematic diagram of the overall architecture of a flight simulation data acquisition system that prevents clock drift and enables high concurrency, provided by the present invention.

[0021] Figure 3 This is a timing diagram of the student-side operation of a flight simulation data acquisition system that provides anti-clock drift and high concurrency, as provided by the present invention.

[0022] Figure 4 This is a timing diagram showing the communication and interaction between a flight simulation data acquisition system with anti-clock drift and high concurrency provided by the present invention and an independent solution engine (Matlab).

[0023] Figure 5This is a flowchart illustrating the unified identity authentication process provided by the JWT-based distributed unified authentication and gateway authentication scheme. Detailed Implementation

[0024] The present invention will now be described in detail with reference to the accompanying drawings and specific embodiments. The following embodiments are explanations of the present invention, but the present invention is not limited to the following implementation methods.

[0025] Example 1: like Figure 1 As shown in the figure, this embodiment provides a flight simulation data acquisition method that prevents clock drift and achieves high concurrency. It adopts a microservice distributed architecture with front-end and back-end separation, and simultaneously supports PC, large-screen, mobile, and third-party access points. The specific steps include: Step S1: The server uses a distributed unified authentication and gateway authentication scheme based on JWT (JSON Web Token) to complete the unified identity authentication of the client. After successful authentication, the client loads the 3D flight simulation experiment scene. like Figure 5 As shown, step S1 specifically includes: In step S11, the client initiates an OAuth 2.0 login request through the Unified Authentication Service (UAA), and the server verifies the client user's identity. Step S12: After the server-side authentication service (UAA) verifies the legitimacy of the client user's identity, it generates a JWT token containing the user's identity and permission information and returns it to the access party. Step S13: The client initiates business access to the Spring Cloud Gateway microservice gateway by carrying a JWT token; Step S14: The microservice gateway parses and verifies the JWT token; Step S15: After successful verification, append the parsed plaintext Token information to the Header of the original request and dynamically route it to the experimental business microservice. Step S16: The client receives the response forwarded by the microservice gateway and loads the 3D flight simulation experiment scene.

[0026] Step S2: The client runs a flight simulation experiment. During the physical phase of the simulation experiment, multiple state anchor points are set through code: "Start Experiment", "In Experiment" and "Experiment End". These state anchor points serve as core data upload nodes. like Figure 3 As shown, this embodiment employs a hybrid active-passive data acquisition method to prevent clock drift, ensuring absolute consistency of experimental progress data. During the flight simulation experiment, when the preset state anchor point is triggered, the client performs a clock-independent active reporting and reports the experiment progress data to the server. When the server detects that the client has not triggered a new state anchor point within a preset threshold time, in order to avoid monitoring blind spots on the instructor management side, a passive reporting instruction is sent to the client through a message queue. The client responds to the instruction and executes passive reporting based on message polling, reporting the experiment progress data to the server. In step S2, the client performs clock-independent active reporting, reporting experimental progress data to the server, specifically including: The client proactively encapsulates the experiment progress data into a JSON format data packet and reports it. During the encapsulation process, no time information from the local device is uploaded to avoid data inconsistencies caused by inaccurate clocks on the student's end.

[0027] In step S2, the client responds to the command and performs passive reporting based on message polling to report the experimental progress data to the server, specifically including: After the client listens for the query command sent by the server in an independent thread, it is passively awakened, immediately collects the current instantaneous experimental progress data, encapsulates the collected experimental progress data into a JSON data packet, and reports it to the server. The JSON format data packet actively reported by the client in step S2 has a data message structure that includes at least the following: a type field that identifies the reporting type, a project number (projID), an experiment number (experimentID), and a progress percentage (progress).

[0028] Step S3: The server receives the experiment progress data, assigns a globally unified system timestamp to the experiment progress data, and stores the experiment progress data. Step S4: Based on the lock-free online user statistics logic of Redis collection, obtain the current online user count of the flight simulation experiment in real time; The lock-free online user counting logic based on Redis Set in step S4 specifically includes: When the server receives the experiment progress data reported by the client, it enters the flight simulation experiment on behalf of the student, extracts the student ID (Identifier) ​​from the client, and directly stores it in a set with the current "experiment ID" as the key. When a student exits normally, switches experiments, or the heartbeat times out, the corresponding student ID is removed from the set using the Redis Remove command. When an instructor requests the current real-time number of online participants for a flight simulation experiment, the server reads the number of elements in the set for that flight simulation experiment to obtain the current number of online participants in microseconds, replacing the traditional full table scan of the database and improving statistical efficiency and system response speed in concurrent scenarios. When the data in the set changes, such as when a student enters or exits an experiment, or when a heartbeat timeout triggers removal, the final statistical data is asynchronously synchronized to the integrated dashboard platform, reducing database I / O load.

[0029] Step S5: If the flight simulation experiment performed by the client involves solving complex aerodynamic or flight mechanics equations, such as aircraft takeoff performance experiments or aircraft lateral stability experiments, and the backend needs to call the Matlab algorithm engine to solve high-order differential equations, then an asynchronous solution mechanism is executed. Since the computation time of the Matlab algorithm is uncertain, using traditional synchronous calls would cause the Spring MVC container thread to be blocked and suspended for a long time, thus affecting the overall concurrency and resource scheduling of the platform. Therefore, this embodiment introduces an asynchronous communication and state transition mechanism combining an asynchronous result object (DeferredResult) and a message queue (RabbitMQ) between the server and the Matlab core solution module. like Figure 4 As shown, the asynchronous solution mechanism in step S5 specifically includes: After receiving the client's calculation request, the server generates a universally unique identifier (UUID), releases the current Servlet container thread, and generates an asynchronous result object (DeferredResult) to enter a blocking listening state. It then pushes the universally unique identifier and simulation parameters (aircraft mass, engine thrust, atmospheric density, etc.) to a message queue. An independent Matlab service node extracts the simulation parameters from the message queue and starts background calculations to obtain the results. For example, it uses the ode45 solver to calculate the ground runway distance and time response array. The calculation result message with the same universally unique identifier is pushed back to the message queue. The microservice listens for and retrieves the calculation result message, matches the corresponding asynchronous result object based on the universally unique identifier, activates the asynchronous result object (DeferredResult), re-allocates a container thread, and sends the final calculation result data to the client in JSON format, driving the 3D engine to perform real-time rendering of the aircraft's attitude.

[0030] Example 2: like Figure 2 As shown, this embodiment provides a flight simulation data acquisition system that prevents clock drift and enables high concurrency. It adopts a microservice distributed architecture with front-end and back-end separation, and supports PC, large-screen, mobile, and third-party access. Specifically, it includes: The client simulation module is built using a cross-platform 3D engine and includes a management terminal for instructors and an operation terminal for students, which is used to provide interactive three-dimensional visualization of flight mechanics and aerodynamics. The microservice gateway and authentication module is deployed in the cloud and provides a unified microservice gateway entry point, dynamic routing and forwarding, and stateless identity authentication. The business processing and state synchronization module is built using a microservice architecture and is used to handle virtual simulation experiment logic, receive client data reports, and issue scheduling instructions. The distributed cache computing module is built using an in-memory database and its built-in Set data structure for lock-free calculation of online status and user count under high concurrency. The asynchronous message-driven module is built using a message queue component and connects the business processing and state synchronization module and the client simulation module. It is used by the server to send passive reporting instructions to the client.

[0031] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. The methods disclosed in the embodiments are described simply because they correspond to the systems disclosed in the embodiments; relevant details can be found in the method section.

[0032] Those skilled in the art will further recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this invention.

[0033] In the embodiments provided by this invention, it should be understood that the disclosed systems, methods, and approaches can be implemented in other ways. For example, the system embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between systems or units may be electrical, mechanical, or other forms.

[0034] 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 units can be selected to achieve the purpose of this embodiment according to actual needs.

[0035] In addition, the functional modules in the various embodiments of the present invention can be integrated into one processing unit, or each module can exist physically separately, or two or more modules can be integrated into one unit.

[0036] Similarly, in the various embodiments of the present invention, each processing unit can be integrated into a functional module, or each processing unit can exist physically, or two or more processing units can be integrated into a functional module.

[0037] The steps of the methods or algorithms described in conjunction with the embodiments disclosed herein can be implemented directly by hardware, a software module executed by a processor, or a combination of both. The software module can be located in random access memory (RAM), main memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, removable disk, CD-ROM, or any other form of storage medium known in the art.

[0038] Finally, it should be noted that in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0039] The above-disclosed embodiments are merely preferred embodiments of the present invention, but the present invention is not limited thereto. Any non-creative variations that can be conceived by those skilled in the art, as well as any improvements and modifications made without departing from the principles of the present invention, should fall within the protection scope of the present invention.

Claims

1. A method for acquiring flight simulation data to prevent clock drift and achieve high concurrency, characterized in that, Includes the following steps: Step S1: The server uses a JWT-based distributed unified authentication and gateway authentication scheme to complete unified identity authentication for the client. After successful authentication, the client loads the 3D flight simulation experiment scene. Step S2: The client runs a flight simulation experiment and sets multiple state anchor points in the physical phase of the flight simulation experiment. During the flight simulation experiment, when the preset state anchor point is triggered, the client performs a clock-independent active reporting and reports the experiment progress data to the server. When the server detects that the client has not triggered a new state anchor point within a preset threshold time, it sends a passive reporting instruction to the client through a message queue. The client responds to the instruction and performs passive reporting based on message polling, reporting the experimental progress data to the server. Step S3: The server receives the experiment progress data, assigns a globally unified system timestamp to the experiment progress data, and stores the experiment progress data. Step S4: Based on the lock-free online user statistics logic of Redis collection, obtain the current online user count of the flight simulation experiment in real time; Step S5: If the flight simulation experiment performed by the client involves solving complex aerodynamic or flight mechanics equations, then an asynchronous solution mechanism is executed.

2. The method for acquiring flight simulation data with anti-clock drift and high concurrency as described in claim 1, characterized in that, Step S1 specifically includes: In step S11, the client initiates a login request through the unified authentication service, and the server verifies the client user's identity. Step S12: After the server-side authentication service verifies the legitimacy of the client user's identity, it generates a JWT token containing the user's identity and permission information. Step S13: The client initiates a business access to the microservice gateway carrying a JWT token; Step S14: The microservice gateway parses and verifies the JWT token; Step S15: After successful verification, append the parsed plaintext information to the header of the original request and dynamically route it to the experimental business microservice. Step S16: The client receives the response forwarded by the microservice gateway and loads the 3D flight simulation experiment scene.

3. The method for acquiring flight simulation data with anti-clock drift and high concurrency as described in claim 1, characterized in that, In step S2, the client performs clock-independent active reporting, reporting experimental progress data to the server, specifically including: The client proactively encapsulates the experimental progress data into a JSON-formatted data packet and reports it, while actively extracting the local device's time node information during the data packet encapsulation process.

4. The method for acquiring flight simulation data with anti-clock drift and high concurrency as described in claim 1, characterized in that, In step S2, the client responds to the command and performs passive reporting based on message polling to report the experimental progress data to the server, specifically including: The client receives a query command from the server, is passively woken up, immediately collects the current instantaneous experimental progress data, encapsulates the collected experimental progress data into a JSON data packet, and reports it to the server.

5. A method for acquiring flight simulation data with anti-clock drift and high concurrency as described in claim 3 or 4, characterized in that, The JSON format data packet actively reported by the client in step S2 has a data message structure that includes at least: a type field that identifies the reporting type, a project number, an experiment number, and a progress percentage.

6. The method for acquiring flight simulation data with anti-clock drift and high concurrency as described in claim 1, characterized in that, The lock-free online user counting logic based on Redis sets in step S4 specifically includes: When the server receives the experiment progress data reported by the client, it enters the flight simulation experiment on behalf of the student, extracts the student ID from the client, and directly stores it in a set with the current "experiment ID" as the key. When the student exits normally, switches experiments, or the heartbeat times out, the corresponding student ID is removed from the set using Redis's remove command. When the instructor requests the current real-time number of online users for a flight simulation experiment, the server reads the number of elements in the set for that flight simulation experiment to obtain the current number of online users. When the data in the set changes, the final statistical data is asynchronously synchronized to the integrated dashboard platform.

7. The method for acquiring flight simulation data with anti-clock drift and high concurrency as described in claim 1, characterized in that, The asynchronous solution mechanism in step S5 specifically includes: After receiving the client's calculation request, the server generates a universally unique identifier, releases the current container thread, and generates an asynchronous result object to enter a blocking listening state. The simulation parameters with the universally unique identifier are pushed to the message queue. The independent core calculation engine node extracts the simulation parameters from the message queue and performs the calculation to obtain the calculation result. The calculation result message with the same universally unique identifier is pushed back to the message queue. The microservice listens for and obtains the calculation result message, matches the corresponding asynchronous result object according to the universally unique identifier, activates the asynchronous result object, re-requests a container thread, and responds to the client with the final calculation result data in JSON format, driving the 3D engine to perform real-time rendering of the aircraft's attitude.

8. The method for acquiring flight simulation data with anti-clock drift and high concurrency as described in claim 1, characterized in that, The state anchor points in step S2 include at least three state nodes: "Start Experiment", "In Experiment" and "End Experiment". Each state anchor point is set by pre-embedding points in the physical phase code of the flight simulation experiment.

9. The method for acquiring flight simulation data with anti-clock drift and high concurrency as described in claim 1, characterized in that, In step S5, after generating the asynchronous result object, the server binds the asynchronous result object with the corresponding universal unique identifier and stores it in the cache, and sets the timeout period. If the corresponding solution result message is not received within the timeout period, the asynchronous result object will be automatically released after the timeout and a solution timeout prompt message will be returned to the client.

10. A flight simulation data acquisition system for preventing clock drift and achieving high concurrency, as described in any one of claims 1-9, is characterized in that... include: The client simulation module is built using a cross-platform 3D engine and provides interactive 3D visualization of flight mechanics and aerodynamics. It includes a management terminal for instructors and an operation terminal for students. The microservice gateway and authentication module is deployed in the cloud and provides a unified microservice gateway entry point, dynamic routing and forwarding, and stateless identity authentication. The business processing and state synchronization module is built using a microservice architecture. It handles virtual simulation experiment logic, receives client data reports, and issues scheduling instructions. The distributed cache computing module is built with an in-memory database and its built-in collection data structure to perform lock-free calculations of online status and number of users under high concurrency. The asynchronous message-driven module is built using a message queue component and connects the business processing and state synchronization module and the client simulation module. It sends passive reporting instructions to the client through the server.

Images