Electric power high-voltage data monitoring and waveform interactive analysis system

Abstract

The invention relates to the technical field of modern electric power systems, and particularly discloses an electric power high-voltage data monitoring and waveform interactive analysis system, which comprises a data receiving layer, an event driving layer, a business processing layer and a front-end rendering layer, the data receiving layer is used for receiving the power high-voltage waveform data in real time and transmitting the power high-voltage waveform data to the event driving layer; the event driving layer is used for dispatching the electric power high-voltage waveform data and transmitting the dispatched electric power high-voltage waveform data to the business processing layer; the business processing layer is used for processing the scheduled power high-voltage waveform data and transmitting the processed power high-voltage waveform data to the front-end rendering layer and the time sequence database; and the front-end rendering layer is used for carrying out rendering optimization on the processed electric power high-voltage waveform data and returning a touch instruction to the business processing layer. According to the invention, the accuracy and real-time performance of power high-voltage monitoring can be greatly improved, and a convenient and powerful waveform analysis tool can be provided for power engineers.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of modern power systems, more particularly, to a power high-voltage data monitoring and waveform interactive analysis system. BACKGROUND

[0002] In modern power systems, high-voltage power transmission, as the main mode of power transmission, its stability and reliability are directly related to the safe operation of the entire power network. With the continuous growth of power demand and the continuous expansion of the power system scale, it is crucial to accurately and real-time monitor the power high-voltage data and conduct in-depth analysis on the related waveforms. Traditional power high-voltage monitoring methods gradually reveal many defects when facing the increasingly complex power environment, such as insufficient data acquisition accuracy, single waveform analysis function, and inability to meet real-time and interactive requirements, etc. These problems seriously restrict the accurate assessment of the power system operation state and the timely warning of potential faults.

[0003] Abroad, some digital oscilloscope products developed by European and American enterprises have high sampling rate and bandwidth, which can accurately collect and preliminarily analyze high-frequency and complex power signals. At the same time, they have mature technology in waveform storage and playback, which is convenient for engineers to review and research historical data. However, these systems still have certain limitations when facing the special needs of the power high-voltage field. Firstly, in the aspect of multi-channel and high-frequency data processing, with the expansion of the power system scale, the data volume grows exponentially, and the existing system is difficult to realize efficient parallel processing, resulting in data processing delay and affecting real-time monitoring effect. Secondly, in the aspect of waveform interaction function, although it has basic measurement and labeling functions, it lacks support for customized analysis of complex power waveforms, and lacks flexible interaction means to meet the diverse analysis ideas of engineers.

[0004] In recent years, domestic research investment in this field has also been increased, and certain progress has been made. Some scientific research institutions and enterprises have developed monitoring and analysis systems based on domestic chips and software platforms, which have advantages in cost performance. Some systems optimize the data acquisition module for power high-voltage monitoring scenarios and improve the adaptability to high-voltage signals. However, in the optimization of data processing algorithms, when a large amount of historical data needs to be queried for a long time, the response speed is slow, which cannot meet the needs of rapid fault diagnosis. In the aspect of waveform rendering and display, real-time performance and visual effects need to be improved, and it is difficult to clearly present the detailed features of complex power waveforms, which affects the accurate interpretation of waveforms by engineers. SUMMARY

[0005] In order to solve the problems in the prior art, the application provides a power high-voltage data monitoring and waveform interactive analysis system, which can greatly improve the accuracy and real-time performance of power high-voltage monitoring, provide a convenient and powerful waveform analysis tool for power engineers, help them deeply understand the operation state of the power system, and quickly locate and solve potential problems.

[0006] As a first aspect of the application, a power high-voltage data monitoring and waveform interactive analysis system is provided, which comprises a data receiving layer, an event-driven layer, a business processing layer and a front-end rendering layer, wherein, The data receiving layer is used for receiving external power high-voltage waveform data in real time and transmitting the received power high-voltage waveform data to the event-driven layer. The event-driven layer is used for scheduling the power high-voltage waveform data and transmitting the scheduled power high-voltage waveform data to the business processing layer. The business processing layer is used for processing the scheduled power high-voltage waveform data and transmitting the processed power high-voltage waveform data to the front-end rendering layer and a time sequence database, respectively. The front-end rendering layer is used for rendering and optimizing the processed power high-voltage waveform data and returning the user's touch control instructions to the business processing layer.

[0007] Further, the data receiving layer comprises a multi-port high-concurrency server unit, a channel mapping unit and a waveform analysis and high-speed forwarding unit, wherein the ports in the multi-port high-concurrency server unit listen to twenty listening ports at the same time, the master thread group and the worker thread group are separated from I / O and business calculation, the fixed-length frame decoder restores the packet according to the frame length of 4096 bytes, the channel mapping unit completes registration, deregistration and activity detection through a channel mapper, the waveform analysis and high-speed forwarding unit performs single-precision floating-point analysis, writes the analysis result into a ring buffer, and then transmits the power high-voltage waveform data to the event-driven layer.

[0008] Further, the multi-port high concurrency server unit is coupled with an application runner interface of a Spring Boot framework, and a network service initialization is triggered by using a framework start completion signal; wherein, (1) after obtaining a start instruction, the Netty server first dynamically detects the number N of central processor cores of a host computer, and constructs the master thread group and the worker thread group according to the ratio of 1 × N and 2 × N, respectively, and an independent worker thread Netty server thread carries all Netty event loops, ensuring that the business thread and the input / output thread are physically isolated; (2) the Netty server has a built-in wave unique identifier table with a length of 20, and each unique identifier corresponds to a physical monitoring port; during the start process, the server uses a countdown lock, and the initial value 20 is used as a synchronization barrier to execute the server booter binding process for twenty times in a loop; The channel mapping unit is based on a concurrent hash mapping table, the key is an integer wave unique identifier, and the value is a channel processing context, so as to realize bidirectional mapping management of the wave unique identifier and the Netty channel; The working process of the wave analysis and high-speed forwarding unit includes a connection establishment stage, a data receiving and analysis stage, and an exception and disconnection processing stage, wherein, (1) in the connection establishment stage, when the channel activation event is triggered by the successful handshake of the client, the Netty server first verifies the validity of the wave data unique identifier and the channel registration table instance; after verification, the registration method is called to register the channel, and the high-performance ring buffer manager is started; then, the handshake success log is outputted; (2) in the data receiving and analysis stage, the channel reads only receives the byte buffer type message, and other types are recorded as an alarm and discarded; the float list of the local variable of the reuse thread is used as a 1024-length data buffer to avoid frequent heap allocation; the float number method is called to parse 1024 float numbers in little-endian order, and if the data is insufficient, it is automatically filled with zero; after the parsing is completed, the immutable list is copied out, the data push method is called to realize zero-lock publishing; in the final execution block, the byte buffer is uniformly released to prevent heap memory leakage; (3) in the exception and disconnection processing stage, when the exception is captured or the channel is deactivated, the Netty server first records detailed logs, then calls the unregistration method to remove the channel mapping, and finally closes the connection to ensure complete recovery of system resources.

[0009] Further, the event-driven layer comprises an event object unit, an event factory unit, an event processing unit and an event scheduling management unit, wherein the event object unit constructs a data event carrying a unique identifier, a system nanosecond timestamp and a floating-point list container; the event factory unit pre-fills 4096 slots; the event processing unit is mounted by a waveform data processor and a listener for concurrent consumption; and the event scheduling management unit drives the ring buffer continuous output by means of lazy loading & singleton start, parallel partition strategy and listener registration / destruction, so as to send the scheduled power high-voltage waveform data into the business processing layer.

[0010] Further, in the event object unit, (1) the data event object adopts a waveform data unique identifier + current timestamp + data container object three-tuple format, wherein the data container object is pre-allocated a 1024-length floating-point list and declared as a final immutable reference to avoid run-time structure migration; and (2) the data container list is emptied by a method, without resetting the waveform data unique identifier, and in cooperation with the object pool reuse strategy of Disruptor, the heap memory application and garbage collection pressure are significantly reduced in a high-frequency writing scenario; The event factory unit is used to implement an event factory interface and is responsible for batch creating data object instances for the full-length slots of the ring buffer in the Disruptor initialization stage, so as to ensure that the existing objects are always reused in the subsequent publishing stage; In the event processing unit, (1) the exclusive waveform data unique identifier is transmitted in the construction parameter, and the event callback first line is compared with the waveform identifier in the event; if they do not match, it is early returned, so as to ensure the data isolation when the ring buffer is parallel processed by multiple processors; (2) the processor holds a list of event listeners, and the data arrival callback is triggered only when the data container is non-empty; the single listener call is wrapped by an exception capture, and any single-point exception does not affect other listeners in the same batch; (3) no matter the processing result, the event object clearing method is finally called, so that the list capacity is immediately recycled for reuse in the next cycle; In the event scheduling management unit, (1) only an empty mapping table is created when the system starts; when the event pushing method arrives for the first time and the ring buffer does not exist, a corresponding Disruptor and event processor are called to start dynamic loading, thereby reducing the cold start cost; (2) an atomic Boolean variable is used for double checking in the global start method and the event pushing method, thereby ensuring that the Disruptor is started only once in a multi-thread concurrent scenario; (3) a Disruptor instance and a ring queue buffer are independently allocated for each unique waveform identifier, and are not locked, thereby achieving twenty-way concurrent writing and concurrent consumption of data; (4) a publish event is called to write an event; the entire publishing process only involves pointer movement and memory writing, and is free of locking, copying and context switching; (5) a data event listener is added or removed, and a write-copy list is used to save UI and a time series database, thereby ensuring the performance balance of concurrent reading and writing safety and less writing and more reading.

[0011] Further, the business processing layer includes a waveform object dispatching unit, which is configured to complete robust filtering, listener broadcasting and event resetting for the scheduled power high-voltage waveform data, and then shunt the processed power high-voltage waveform data to a real-time pushing channel and an asynchronous time series data persistence channel; wherein, In the real-time pushing channel, the processed power high-voltage waveform data is transmitted to the front-end rendering layer through accurate subscription filtering, a thread pool and instruction return; In the asynchronous time series data persistence channel, the same batch of processed power high-voltage waveform data is written into the time series database through list assignment & serialization, task submission and asynchronous writing, and the life cycle management is completed through a data elimination mechanism.

[0012] Further, in the waveform object dispatching unit, (1) first compare the waveform unique identifier, and immediately return if there is no match; if there is a match, check whether the data container is empty, and discard if it is empty; (2) execute listener broadcasting for valid events: call the time series database listener and the real-time pushing listener one by one, and wrap exception capture each time to ensure that single-point failure does not spread; reset the event object immediately after completion; (3) time series database listener path: copy the floating point list and encapsulate it as a JSON data point, submit a writing task to a dedicated thread pool, and asynchronously write to a specified data bucket to achieve high-throughput persistence; (4) first filter the subscribers in the WebSocket session set; if there are no subscribers, terminate; if there are, construct a real-time DTO, serialize the JSON, and submit a sending task to the WebSocket thread pool; lock the session inside the task and then push it to the browser end to achieve concurrent and safe millisecond-level updates.

[0013] Further, the front-end rendering layer includes a rendering receiving unit, a data caching unit, a waveform drawing unit, a user interaction unit, a thread coordination unit and a state synchronization unit, wherein the rendering receiving unit is responsible for configuration fallback, heartbeat keep-alive, exponential backoff reconnection and uplink interface; the data caching unit constructs zero-lock buffer according to multi-producer, waiting strategy, single-consumer and nanosecond-level publishing; the waveform drawing unit writes the processed power high-voltage waveform data millisecond-level into canvas through incremental drawing, adaptive frame rate and switching hook; the user interaction unit provides waveform switching, history page turning, position control, capture interval frame, waveform down-sampling, vertical and horizontal scale adjustment, performance index monitoring and waveform parameter control; the thread coordination unit uses reconnection scheduling pool and factory thread to manage background tasks; and the state synchronization unit completes multi-end state synchronization and multi-end start-stop.

[0014] Further, the rendering receiving unit serves above the data receiving layer, is soft-bound with a configuration attribute file, dynamically generates and connects a server through a singleton factory to obtain an instance; the data caching unit is based on a high-performance lock-free ring buffer framework architecture, and is responsible for concurrent buffering and event delivery of the power high-voltage waveform data sent by the rendering receiving unit.

[0015] The power high-voltage data monitoring and waveform interactive analysis system provided by the application has the following advantages: efficient monitoring of power high-voltage data and flexible waveform interactive analysis are realized, not only the accuracy and real-time performance of power high-voltage monitoring can be greatly improved, but also a convenient and powerful waveform analysis tool can be provided for power engineers to help them deeply understand the operation state of the power system and quickly locate and solve potential problems. From the perspective of industry development, the system is expected to promote the upgrading of power high-voltage monitoring and analysis technology, promote the intelligent and fine transformation of the power system operation and maintenance mode, provide solid technical support for the safe, stable and efficient operation of the power system, and has far-reaching significance for the technological innovation and sustainable development of the entire power industry. BRIEF DESCRIPTION OF DRAWINGS

[0016] The accompanying drawings are included to provide a further understanding of the application, and constitute a part of the specification, and together with the specific embodiments below, serve to explain the application, but do not constitute a limitation on the application.

[0017] Figure 1 The structure diagram of the power high-voltage data monitoring and waveform interactive analysis system proposed by the application. DETAILED DESCRIPTION

[0018] For further illustrating the technical means and effects taken by the present application to achieve the predetermined object, the following will be described in detail the specific implementation, structure, features and effects of the power high-voltage data monitoring and waveform interactive analysis system according to the present application, with reference to the accompanying drawings and preferred embodiments. Obviously, the described embodiments are part of the embodiments of the present application, rather than all the embodiments. Based on the embodiments of the present application, all other embodiments obtained by those skilled in the art without creative work fall within the protection scope of the present application.

[0019] It should be noted that the terms "first", "second" and the like in the description and claims of the present application and the above-described accompanying drawings are used to distinguish similar objects, and do not necessarily indicate a specific order or sequence. It should be understood that the data thus used can be interchanged under appropriate circumstances, so that the embodiments of the present application described herein can be implemented. In addition, the terms "include" and "have" and any variations thereof are intended to cover non-exclusive inclusion, for example, a process, method, system, product or device including a series of steps or units does not necessarily limit to those steps or units clearly listed, but can include other steps or units not clearly listed or inherent to these processes, methods, products or devices.

[0020] In the explanation of the present application, it should be noted that the terms "mount", "connect", "connect" should be understood broadly, unless otherwise specified. For example, the connection can be a fixed connection, or it can be connected through a special interface, or it can be indirectly connected through an intermediate medium. For those skilled in the art, the specific meaning of the above terms in the present application can be understood according to the specific circumstances.

[0021] In the present embodiment, a power high-voltage data monitoring and waveform interactive analysis system is provided, as shown in Figure 1 The power high-voltage data monitoring and waveform interactive analysis system comprises a data receiving layer, an event-driven layer, a business processing layer and a front-end rendering layer; wherein, The data receiving layer is used to receive the power high-voltage waveform data of the external (TCP client & embedded device) in real time, and transmit the received power high-voltage waveform data to the event-driven layer; The event-driven layer is used to schedule the power high-voltage waveform data, and transmit the scheduled power high-voltage waveform data to the business processing layer; The business processing layer is used to process the scheduled power high-voltage waveform data, and transmit the processed power high-voltage waveform data to the front-end rendering layer and the time series database, respectively; The front-end rendering layer is used to render and optimize the processed power high-voltage waveform data, and return the user's touch instruction to the business processing layer.

[0022] Preferably, the data receiving layer comprises a multi-port high-concurrency server unit, a channel mapping unit, and a waveform analysis and high-speed forwarding unit, which are sequentially coupled and work cooperatively to realize real-time access, unified management, and high-speed distribution of external twenty-way power high-voltage waveform data. Among them, the port listening cluster in the multi-port high-concurrency server unit simultaneously opens twenty listening ports, the master thread group and the worker thread group are separated from I / O and business calculation, and the fixed-length frame decoder restores the packet according to the frame length of 4096 bytes; the channel mapping unit completes registration, deregistration, and activity detection through the channel mapper; the waveform analysis and high-speed forwarding unit performs single-precision floating-point analysis and writes the analysis results into a ring buffer, and then transmits the power high-voltage waveform data to the event-driven layer.

[0023] Specifically, the multi-port high-concurrency server unit is coupled with the application program runner interface of the Spring Boot framework, and the network service initialization is triggered by the framework startup completion signal; wherein, (1) thread isolation and resource estimation: after obtaining the startup instruction, the Netty server first dynamically detects the number N of central processor cores of the host, constructs the master thread group and the worker thread group according to the ratio of 1 × N and 2 × N respectively, and loads all Netty event loops with independent worker threads Netty server threads to ensure physical isolation of business threads and input / output threads; (2) concurrent start of port clustering: the Netty server has a waveform unique identifier table with a length of 20; each unique identifier corresponds to a physical listening port; during the startup process, the server uses a countdown lock with an initial value of 20 as a synchronization barrier, and executes the server director binding process for twenty times in a loop; wherein, the server director binding process is as follows: 1. Set the non-blocking server Socket channel model; 2. Inject a channel initializer in the sub-processor, write the unique identifier attribute to the socket channel, and sequentially load the fixed-length frame decoder 4096 bytes and the waveform-specific processor; 3. Configure high-throughput parameters (SO_BACKLOG = 1024, TCP_NODELAY, SO_RCVBUF / SO_SNDBUF = 64KB, pooled byte buffer allocator); 4. Bind the port number = waveform unique identifier, and get the channel asynchronous result; 5. The counter is decremented and the "port ready" log is recorded. When the counter is zero, the Netty server records the "all twenty ports startup complete" information and enters the blocking state, waiting for channel close events; after the channel is closed, the thread resources are released uniformly.

[0024] The channel mapping unit realizes bidirectional mapping management of the waveform unique identifier and the Netty channel based on a concurrent hash mapping table, the key being an integer waveform unique identifier, and the value being a channel processing context; in the channel mapping unit: (1) Constant level registration / deregistration: Registration: directly inserted after passing parameter verification, recording the waveform unique identifier and the short channel unique identifier; Deregistration: safely removing the mapping according to the unique identifier; Deregistration context: realizing reverse deregistration by traversing the table item and comparing the context, to prevent memory leakage.

[0025] (2) Active channel real-time detection The current channel is first judged for the active state before returning the context according to the unique identifier; if the inactivation is detected, the dirty data is immediately removed and an empty value is returned, so that the business layer only operates the writable channel.

[0026] The working process of the waveform analysis and high-speed forwarding unit includes a connection establishment stage, a data receiving and analysis stage, and an exception and disconnection processing stage, wherein (1) in the connection establishment stage, when the client handshake successfully triggers the channel activation event, the Netty server first verifies the validity of the waveform data unique identifier and the channel registration table instance; after the verification, the registration method is called to register the channel, and the high-performance ring buffer manager is started, and then the handshake success log is output; (2) in the data receiving and analysis stage, the channel reads only receives the byte buffer type message, and other types are recorded as an alarm and discarded; the float list of the local variable of the reuse thread is used as a 1024-length data buffer to avoid frequent heap allocation; the float number method is called to parse 1024 float numbers in little-endian order from the byte buffer, and if the data is insufficient, it is automatically zero-filled; after the parsing is completed, the immutable list is copied out, the data push method is called to realize zero-lock publishing; in the final execution block, the byte buffer is uniformly released to prevent heap memory leakage; (3) in the exception and disconnection processing stage, when the exception is captured or the channel inactivation is triggered, the Netty server first records the detailed log, then calls the deregistration method to remove the channel mapping, and finally closes the connection to ensure that the system resources are completely recycled.

[0027] Through the above structural design, the application realizes millisecond-level access, nanosecond-level publishing and millisecond-level persistence of twenty high-concurrency waveform data, fully meeting the strict time efficiency requirements of real-time monitoring and control of power electronic equipment.

[0028] In the embodiment of the application, the working method of the data receiving layer is as follows: Step one: after the Spring Boot completes the component initialization, the application executor calls the running method to trigger the multi-port server to start; Step two: Netty service processor loops twenty times to perform port binding until the countdown lock is cleared, and each port enters a listening state; Step three: the client initiates a connection to any port, triggering a channel activation callback, completing channel registration and starting a high-performance ring buffer; Step four: the client continuously pushes waveform data in fixed-length packets of 4096 bytes / frame, and the Netty service processor writes a list of floating-point numbers, 1024 in length, to Disruptor after parsing; Step five: the Disruptor ring buffer routes events to subsequent listeners (time series database listeners, front-end data listeners, etc.) based on waveform numbers to complete persistence or UI rendering; Step six: when the connection is abnormal or normally disconnected, the Netty service processor actively unregisters the channel registry mapping, and the Netty service processor senses and finally releases thread resources in the close result callback.

[0029] Preferably, the event-driven layer takes a high-performance ring buffer high-throughput ring queue framework as the core to realize "zero-lock diffusion, quasi-real-time dispatch" of waveform event scheduling. This layer connects the five-level architecture of the system: it connects the 1024 floating-point list waveform frames from the data receiving layer and drives the business processing layer to complete index calculation, anomaly detection and persistence. The event-driven layer includes an event object unit, an event factory unit, an event processing unit, and an event scheduling management unit. The event object unit constructs a data event carrying a unique identifier, a system nanosecond timestamp, and a floating-point list container; the event factory unit pre-fills 4096 slots; the event processing unit mounts and concurrently consumes through a waveform data processor and a listener; and the event scheduling management unit uses lazy loading & singleton startup, parallel partitioning strategy, and listener registration / destruction to drive the ring buffer to continuously output, so as to send the scheduled power high-voltage waveform data to the business processing layer.

[0030] Specifically, in the event object unit, (1) data structure and capacity presetting: the data event object adopts a waveform data unique identifier + current timestamp + data container object three-tuple format, wherein the data container object is pre-allocated a 1024-length floating-point list and declared as a final immutable reference to avoid runtime structure migration; (2) object reuse mechanism: only empty the data container list through the empty method without resetting the waveform data unique identifier, and cooperate with the object pool reuse strategy of Disruptor to significantly reduce heap memory allocation and garbage collection pressure in high-frequency writing scenarios; The event factory unit is used to implement the event factory interface and is responsible for batch creating data object instances for the full-length slots of the ring buffer in the Disruptor initialization stage, ensuring that existing objects are always reused in the subsequent publishing stage; In the event processing unit, (1) responsibility waveform isolation: the unique identifier of the incoming dedicated waveform data is constructed in the parameter, and the event waveform identifier is compared in the first line of the event callback; if it does not match, it is early returned, and the data isolation of the same ring buffer multi-processor parallel is ensured; (2) listener notification: the processor holds the event listener list, and when and only when the data container is not empty, the triggered data reaches the callback; the single listener call is wrapped by capturing an exception, and any single-point exception does not affect other listeners in the same batch; (3) event reset: no matter the processing result, the final block calls the event object clearing method, and the list capacity is recycled immediately for reuse in the next cycle; In the event scheduling management unit, (1) lazy loading initialization: only an empty mapping table is created when the system starts; when the event push method arrives for the first time and the ring buffer does not exist, the corresponding Disruptor and event processor are dynamically loaded by calling the start Disruptor, reducing the cold start cost; (2) singleton start guarantee: an atomic Boolean variable is used for double checking in the global start method and the event push inside, ensuring that the Disruptor is started only once in a multi-thread concurrent scenario; (3) parallel partitioning strategy: a Disruptor instance and a ring queue buffer are independently allocated for each waveform unique identifier, and are not locked, achieving twenty-way data concurrent writing and concurrent consumption; (4) event publishing process: call the publish event, write the event: clear the original data container → add data → set the data container unique identifier → set the timestamp; the entire publishing process only performs pointer movement and memory writing, without locking, copying or context switching; (5) listener management: add / remove data event listeners are exposed, and a write-copy-on-write list is used to save UI and time series databases, ensuring the performance balance of concurrent read-write safety and write-less read-more.

[0031] In the embodiment of the application, the workflow of the event-driven layer is as follows: 1. The data receiving layer submits a 1024 floating point number list frame to the event scheduling manager; the scheduler first checks whether the Disruptor instance corresponding to the waveform exists; if not, the instance is lazily loaded and created, and the ring buffer is batch-constructed by the event factory.

[0032] 2. The scheduler only completes the lambda callback in the publishing phase through pointer movement and memory writing: clear the old container → write new data → set the waveform unique identifier → mark the timestamp, and the whole process is lock-free and copy-free.

[0033] 3. The filled event enters the ring buffer and is routed to the event processor of the corresponding waveform. The processor first judges whether the waveform ID matches; if not, it is immediately early returned, ensuring parallel isolation.

[0034] 4. After the matching is successful, the processor traverses its listener list (UI, time series database, etc.), and wraps a try-catch call for each listener to achieve single-point exception isolation; after the callback is completed, the data list in the event object is emptied for reuse in the next cycle.

[0035] 5. The entire manager implements a parallel partitioning strategy of "independent Disruptor + ring buffer" for 20 waveforms, and ensures singleton startup safety through atomic Boolean and double-checking, finally realizing the millisecond-level queue scheduling capability of "zero lock diffusion, quasi-real-time dispatch".

[0036] Preferably, the business processing layer includes a waveform object dispatch unit, which is used to complete the processing of robustness filtering, listener broadcasting and event resetting for the scheduled power high-voltage waveform data, and then shunt the processed power high-voltage waveform data to a real-time push channel and an asynchronous time series data persistence channel; wherein, In the real-time push channel, the processed power high-voltage waveform data is transmitted to the front-end rendering layer through precise subscription filtering, thread pool and instruction return; Specifically, in the real-time push channel, (1) precise subscription filtering: after receiving the event, first traverse the session set in the WebSocket server to determine whether there is a session that subscribes to the current waveform unique identifier and is not in the historical viewing mode; if there is no subscriber, return immediately to avoid invalid serialization and network overhead; (2) DTO construction and serialization: construct a real-time data transmission object, the fields include type, waveform identifier, timestamp, and value list, then use FastJSON2 to serialize it into a string and cache it as a text message. (3) Asynchronous sending and concurrent safety: when traversing the session, submit a task to the WebSocket task thread pool for each target session; lock the attribute mapping of the session inside the task, and send after rechecking whether it has been opened to ensure the message order and connection effectiveness in concurrent scenarios.

[0037] In the asynchronous time series data persistence channel, the processed power high-voltage waveform data in the same batch is written into the time series database through list assignment & serialization, task submission, and asynchronous writing, and the life cycle management is completed through the data elimination mechanism.

[0038] Specifically, in the asynchronous timing data persistence channel, (1) life cycle management: the timing database client, write interface and 2-4 thread dedicated write thread pool are created in the post-initialization stage; the thread pool and connection are closed gracefully in the pre-destruction stage to ensure that the data flushing is completed; (2) data encapsulation: after the method receives waveform data, the internal float list is copied first, then serialized to JSON, and the data point of the measurement point name is constructed, with a unique identification tag and count, sampling interval field; (3) asynchronous writing: the complete data point object is encapsulated as a task and submitted to the thread pool, and finally the write method is called to write to the specified data bucket to complete high-throughput persistence.

[0039] Specifically, in the waveform object dispatching unit, (1) first compare the waveform unique identifier, and immediately return if they do not match; if they match, check whether the data container is empty, and discard if it is empty; (2) execute listener broadcast for valid events: call the timing database listener and real-time push listener one by one, each call is wrapped with exception capture to ensure that single point failure does not spread; reset the event object immediately after completion; (3) timing database listener path: copy the float list and encapsulate it as a JSON data point → submit a write task to a dedicated thread pool → asynchronously write to a specified data bucket to achieve high-throughput persistence; (4) first filter subscribers in the WebSocket session set; if there are no subscribers, terminate; if there are, construct a real-time DTO, serialize JSON, and submit a send task to the WebSocket thread pool; the task internally locks the session and then pushes it to the browser end to achieve concurrent and secure millisecond-level updates.

[0040] In the embodiment of the application, the technical points of the waveform object dispatching unit are as follows: (1) waveform responsibility isolation: the constructor injects the waveform unique identifier, and the event callback compares the event internal identifier in the first line, and returns if they do not match, to ensure that twenty-way data is parallel and does not interfere with each other; (2) empty data discard: early filtering of events with empty data containers saves subsequent calculation and input / output overhead; (3) listener broadcast: the observer pattern is used to traverse the event object listener interface list, and the data receiving method is triggered one by one; each call is wrapped with an exception capture block, and any single point exception does not affect other listeners in the same batch; (4) object reset: the event object clear method is called in the final block to immediately recycle the list capacity for reuse.

[0041] At this point, the business processing layer realizes the dual-path guarantee of "second-level persistence + millisecond-level push", which meets the needs of archiving massive historical data and real-time observation by engineers, forming a complete closed loop.

[0042] In the embodiment of the application, the workflow of the business processing layer is as follows: 1. The data event published by the event-driven layer enters the waveform distribution and monitoring callback unit; first, the waveform unique identifier is compared, and if it does not match, it is immediately returned; if it matches, it is checked whether the data container is empty, and if it is empty, it is discarded.

[0043] 2. Perform listener broadcast on valid events: call time series database listeners and real-time push listeners one by one, each call is wrapped with exception capture to ensure that single point failure does not spread; reset the event object immediately after completion.

[0044] 3. Time series database listener path: copy the floating point list and encapsulate it as a JSON data point → submit a write task to a dedicated thread pool → asynchronously write to the specified data bucket to achieve high-throughput persistence.

[0045] 4. Real-time push listener path: first filter subscribers in the WebSocket session set; if there are no subscribers, terminate; if there are, construct a real-time DTO, serialize JSON, and submit a send task to the WebSocket thread pool; lock the session inside the task and push it to the browser end to achieve concurrent and secure millisecond-level updates.

[0046] 5. The two channels are independent and executed in parallel, forming a "second-level persistence + millisecond-level push" dual-path business loop.

[0047] Preferably, the front-end rendering layer includes a rendering receiving unit, a data caching unit, a waveform drawing unit, a user interaction unit, a thread coordination unit, and a state synchronization unit, which are sequentially coupled and work together to achieve lock-free reception, millisecond caching, microsecond drawing, and interaction synchronization of twenty high-speed waveform data from the back-end, wherein the rendering receiving unit is responsible for configuring fallback, heartbeat keep-alive, exponential backoff reconnection, and uplink interface; the data caching unit builds a zero-lock buffer based on multiple producers, wait strategy, single consumer, and nanosecond-level publishing; the waveform drawing unit writes the processed power high-voltage waveform data millisecond-level to the canvas through incremental drawing, adaptive frame rate, and switching hook; the user interaction unit provides waveform switching, history paging, position control, frame capture, waveform downsampling, vertical and horizontal scale adjustment, performance monitoring, and waveform parameter control; the thread coordination unit uses a reconnection scheduling pool and factory threads to manage background tasks; the state synchronization unit completes multi-end state synchronization and multi-end start and stop.

[0048] Specifically, the rendering receiving unit serves above the data receiving layer, and is dynamically generated and connected to the server through a singleton factory by soft binding with a configuration attribute file; (1) starting detection and automatic injection: the WebSocket obtains an application class loader, reads three attributes of address, port, and endpoint; if the configuration is missing, it is respectively backed up to the default value to ensure that the device can also be self-booted in a configuration file environment. The instance construction is immediately invoked to set the connection loss timeout to 30 seconds to form a 30-second bidirectional heartbeat; then, the connection is established before the UI initialization, and the handshake is started. After the handshake is successful, the connection open callback is triggered to automatically issue the "switch waveform" instruction, and the waveform number is default to 11111; if the user has selected other waveforms in the UI, the default behavior is overwritten by the main controller. (2) Message decoding and classification distribution: the received text message uniformly receives a JSON string, and is shunted according to the type field, supporting four types of real-time waveform / historical waveform / global state update / parameter update; the real-time waveform data is directly parsed into a waveform data transmission object and transferred to the data cache unit; the historical page data is constructed into a double-precision floating-point list and handed over to the user interaction unit; the global state and parameter update are written into the JavaFX thread by using the JavaFX main thread queue. (3) Exponential backoff self-recovery: the connection close callback first records the close code and the close source; then the atomic reconnection counter is read, and if the counter < 5, the reconnection waiting time is calculated; the thread is renamed by using the scheduled task executor and the try-reconnect task is submitted; the try-reconnect internally calls the blocking reconnection and synchronously waits for the connection result; after success, the counter is cleared and re-entered into the "message decoding" process; failure increments the counter and retries, until the limit is exceeded. (4) High-performance uplink interface: encapsulate the switch command instruction to change the current waveform in real time; encapsulate the read command instruction for historical playback; support floating-point control parameters and Boolean-type whole machine on-off operations respectively; all uplink interfaces internally call JSON serialization and are sent out through the web socket without locking.

[0049] The data cache unit is based on a high-performance lock-free ring buffer framework, and is responsible for concurrent buffering and event delivery of power high-voltage waveform data sent by the rendering receiving unit; (1) ring buffer configuration: the buffer capacity is 4096, which is exactly 2 nThe producer mode adopts a multi-producer mode, supports multi-threaded simultaneous submission, and selects a yield type waiting strategy to yield to thread switching instead of sleeping in an ultra-low delay scenario. The thread factory renames the thread, sets the priority to the highest priority, and marks it as a daemon thread. (2) Event publishing process: when the rendering receiving unit calls to publish waveform data, it first executes the occupation sequence number to obtain a sequence number; then obtains a data event object through the sequence number and writes the waveform data object and the creation time in nanoseconds; if there is no exception in writing, the publishing sequence number is called to publish externally; if an exception is thrown during writing, the log is recorded in the capture block and the publishing is skipped to avoid polluting the buffer. (3) Event consumption link: the Disruptor instance binds a unique consumer data event processor in the initialization stage; the consumer maintains a write-time copy list listener set, and the canvas waveform data listener is registered by default; if the main controller needs to add a waveform processor, the listener can be added in the UI thread. (4) Shutdown and resource recycling: when the application exits, the main controller calls the shutdown manager, which compares and exchanges the set bit in sequence to stop the ring buffer, stop the thread, and clear the events, ensuring that there is no resource leakage.

[0050] The waveform drawing unit is a waveform drawing core and resides on the JavaFX application thread; (1) Source data filtering: in the waveform data collection method, first detect whether the current waveform data unique identifier is consistent with the local unique identifier; if not, return directly to realize concurrent subscription of multiple waveforms by the same listener without interference; perform null verification on the array; if the list is empty or has a length of 0, record a warning and return. (2) Double-buffering incremental drawing: the waveform canvas object maintains an off-screen buffer internally, and all new data is first written to the memory buffer and then merged to the visible canvas in batches in the JavaFX animation timer callback; when the number of drawing points exceeds the canvas width in pixels, the "overall translation by one pixel + end point supplement" strategy is used to realize scrolling to avoid full-width redrawing; the frame rate value is detected every 50 milliseconds, and when the frame rate is lower than 60 Hz, the sampling point drawing density is automatically reduced to ensure smooth UI. (3) Waveform switching hook: when the main controller calls to set the current waveform unique identifier, the canvas waveform listener clears the waveform canvas drawing buffer and calls the clear rectangle to clear the screen, blocking the residual image of the previous waveform; immediately after switching, the next frame of real-time data is responded to ensure continuous user experience.

[0051] In the user interaction unit, (1) control binding: the waveform drop-down box and the integer combination box map 20 physical channels; the history page button group, the previous page / next page button and the page number text box complete the history window switching; the parameter adjustment panel slider and the check box correspond to the single-precision floating-point type PID parameter and the Boolean type start-stop amount respectively; all control binding attribute objects are used to synchronize the UI and the backend state by using JavaFX bidirectional binding. (2) Instruction dispatching: the waveform switching method is called by triggering the hook when the waveform is selected after the user selects the waveform; the history reading mode command is sent after the history playback button is clicked; the control command or the operation command is sent immediately after the parameter panel changes, without explicit submission. (3) Running state protection: the parameter slider and the start button are automatically disabled when the state synchronization mechanism judges whether the running state value is false; the real-time drawing button is locked after entering the history mode, and the real-time completion is restored. (4) Exit hook: the window closing event is listened to, the channel closing method, the Disruptor closing method and the thread coordination unit closing method are called in turn, and finally the platform exit method is executed, so that no background thread survives before the JVM exits.

[0052] In the state synchronization unit, (1) global state update: whether the running state is updated is analyzed, and the global state update is called by the JavaFX main thread queue processor; (2) parameter update: the parameter update is called after the key is analyzed to automatically refresh the slider or the check box. If the message lacks the key value pair field, the warning log is recorded and ignored; when the UI thread is blocked, the runLater queue is congested, and the 50 ms or more old messages are automatically discarded.

[0053] In the thread coordination unit, (1) reconnection scheduling pool: a single-threaded scheduling executor creates a thread; (2) Disruptor factory thread: a custom thread factory generates a thread, sets the highest priority and overrides the uncaught exception processor; (3) unified closing interface: the closing method of the main controller terminates the daemon thread within 3 s by using the de-queuing closing and thread closing methods.

[0054] In the embodiment of the application, the workflow of the front-end rendering layer is as follows: 1. After the JavaFX platform is started, the controller loads the FXML layout, and immediately calls the singleton method to obtain an object, establishes a connection and sends the "waveform 11111" switching instruction.

[0055] 2. The server pushes the real-time waveform JSON frame; after the WebSocket is parsed, the data event object is published by using the Disruptor.

[0056] 3. The Disruptor callback canvas waveform listener writes into the incremental cache; the waveform canvas is rendered in the animation timer, and the single-frame time consumption is ≤ 0.8 ms.

[0057] 4. In history mode, the controller sends read instructions; after receiving the wave data list, draw the history curve in the JavaFX thread.

[0058] 5. Network interruption triggers the shutdown method, exponential backoff for reconnection; when reconnection fails five times, pop up a "network exception" dialog box.

[0059] 6. When the application exits, close WebSocket, Disruptor, daemon threads, release GPU and heap resources, and ensure clean JVM exit.

[0060] In the embodiment of the application, the specific workflow of the front-end rendering layer is as follows: 1. The server continuously pushes JSON waveform frames, which first enter the "multi-protocol self-recovery rendering receiver". The receiver parses the type: real-time waveform is written to the "zero lock ring buffer", and historical waveform is handed over to the user interaction unit; global state / parameter update is queued to the JavaFX main thread through state synchronization.

[0061] 2. The zero lock ring buffer caches data in a 4096 slot ring buffer, single producer / consumer lockless publishing; the only consumer "incremental pixel renderer" reads data in the JavaFX thread.

[0062] 3. The incremental pixel renderer uses off-screen double buffering incremental rendering: data is first written to the off-screen cache, and then batched to the visible canvas through animation timer, and scrolling display is achieved through overall translation + end point filling.

[0063] 4. The user controls the UI components such as drop-down box, button, slider, etc. through the "main controller". The main controller is responsible for: sending waveform switching / history query instructions to the receiver; dynamically adding listeners to the renderer; synchronizing UI operations to the canvas and state display.

[0064] 5. The state synchronization bridge is responsible for safely dispatching backend state and parameter updates to the JavaFX thread, and the main controller starts and stops the controls or refreshes the parameters accordingly.

[0065] 6. The thread coordination unit manages background threads: provides a reconnection scheduling pool for the receiver and a Disruptor factory thread for the buffer; the main controller calls the unified shutdown interface when the application exits, and all daemon threads are terminated within 3 seconds.

[0066] The front-end rendering layer forms a closed loop of "receiving -> caching -> rendering -> interaction -> synchronization -> scheduling" from top to bottom: nanosecond-level caching, millisecond-level rendering, and second-level self-recovery, which ensures that twenty 1-kilohertz waveforms are smoothly and real-time presented on a 1080P canvas.

[0067] In the embodiments of the present application, the technical effects and improvement points of the front-end rendering layer are as follows: 1. Nanosecond-level caching + millisecond-level rendering: Disruptor zero-lock ring buffer brings <1 millisecond end-to-end delay; canvas incremental rendering occupies <20% of the core controller at 1080P resolution.

[0068] 2. High-reliability self-recovery connection: exponential backoff + heartbeat detection, average recovery <3 seconds; 99.9% availability under 40% packet loss environment.

[0069] 3. Twenty-way concurrent rendering: 1 kilohertz sampling per way, total throughput 20 kilohertz; 4096 slot buffer peak suppression, no frame loss.

[0070] 4. Master-slave thread safety separation: UI updates are encapsulated through the JavaFX main thread queue; all background threads are daemon threads and are automatically terminated when the application exits.

[0071] 5. Plug and play and configurability: server parameters can be modified in the configuration file hot plug, and default values are used when missing to reduce deployment cost.

[0072] Through the above structured design, the front-end rendering layer of the present application realizes high-speed access, zero-lock concurrent caching and millisecond-level visual rendering of twenty real-time waveform data, significantly improves the real-time performance and operability of industrial field monitoring, and provides key visualization support for the "high-speed acquisition-processing-pushing system for twenty real-time waveforms".

[0073] It should be noted that the front end is based on the JavaFX platform to build a visual interaction framework, and the Disruptor event bus is innovatively introduced to decouple the UI thread and the rendering thread, ensuring the immediacy of the interaction response. In the front-end rendering layer, Canvas 2D graphics context is combined with off-screen rendering technology, and LTTB (Douglas-Poole algorithm) data downsampling strategy is used to realize real-time rendering optimization of millions of data points. When the system is packaged, the GPU hardware acceleration mode of the Prism graphics engine is enabled, and the rendering task is offloaded to the graphics processor through the OpenGL pipeline, effectively improving the dynamic refresh rate and visual smoothness of complex waveforms. Through the bidirectional communication mechanism based on event-driven, the front and back ends build a millisecond-level delay data closed-loop processing system, realizing the whole-linkage technical cooperation from data acquisition, analysis and processing to visualization interaction.

[0074] The power high-voltage data monitoring and waveform interactive analysis system provided by the application needs to meet the strict requirements of data acquisition, processing, analysis and interaction under the power high-voltage monitoring scene. The specific research content covers multiple key aspects: (1) in the data acquisition and processing link, how to realize the low-delay acquisition and efficient processing of multi-channel, high-frequency power high-voltage data is focused on. By optimizing the data acquisition algorithm and hardware interface, combined with advanced signal processing technology, it is ensured that the system can quickly and accurately acquire power high-voltage signals and complete preliminary processing in a very short time, providing a high-quality data basis for subsequent analysis and display. (2) For waveform analysis and display, high-performance waveform rendering algorithms are developed to realize smooth and accurate display of real-time and historical waveforms. At the same time, a rich waveform analysis tool library is built to support multiple common power waveform analysis functions such as harmonic analysis, phase analysis, fault waveform feature extraction, etc., to meet the needs of engineers for in-depth analysis of power high-voltage waveforms. (3) In the design of interactive functions, the principle of user-friendly is adhered to, and an intuitive and flexible waveform interaction interface is developed. Basic interactive operations such as zooming, panning, marking and measuring of waveforms are realized, and innovative interaction modes such as multi-waveform collaborative analysis, gesture or voice-based interaction control, etc. are explored to improve the interaction efficiency of engineers and the system, so that they can freely customize the analysis process according to the actual analysis needs. (4) In addition, system performance optimization is also an important research content. Through optimization of system architecture, algorithm, hardware resource utilization and other aspects, the overall operation efficiency of the system is improved, resource consumption is reduced, and the system can still maintain stable and efficient performance under long-time and high-load running conditions.

[0075] The above is only the preferred embodiment of the application, not any form of limitation on the application, although the application has been disclosed as above with the preferred embodiment, however, it is not intended to limit the application, any skilled person in the art, without departing from the technical solution of the application, can make some changes or modifications to the above disclosed technical content to make equivalent embodiments with equivalent changes, but as long as it does not deviate from the technical solution of the application, any simple modification, equivalent change and modification of the above embodiments according to the technical essence of the application, all still belong to the scope of the technical solution of the application.

Claims

1. A power high-voltage data monitoring and waveform interactive analysis system, characterized in that, The high-voltage power data monitoring and waveform interactive analysis system includes a data receiving layer, an event-driven layer, a business processing layer, and a front-end rendering layer; among which... The data receiving layer is used to receive external high-voltage power waveform data in real time and transmit the received high-voltage power waveform data to the event-driven layer. The event-driven layer is used to schedule the high-voltage power waveform data and transmit the scheduled high-voltage power waveform data to the business processing layer. The business processing layer is used to process the scheduled high-voltage power waveform data and transmit the processed high-voltage power waveform data to the front-end rendering layer and the time-series database respectively. The front-end rendering layer is used to optimize the rendering of the processed high-voltage power waveform data and to send the user's touch commands back to the business processing layer.

2. The high-voltage power data monitoring and waveform interactive analysis system according to claim 1, characterized in that, The data receiving layer includes a multi-port high-concurrency server unit, a channel mapping unit, and a waveform parsing and high-speed forwarding unit. The multi-port high-concurrency server unit simultaneously opens twenty listening ports in its port listening cluster. The main control thread group and worker thread group separate I / O and business computation. The fixed-length frame decoder restores the message with a frame length of 4096 bytes. The channel mapping unit completes registration, deregistration, and activity detection through a channel mapper. The waveform parsing and high-speed forwarding unit performs single-precision floating-point parsing and writes the parsing result into a circular buffer, then transmits the high-voltage power waveform data to the event-driven layer.

3. The high-voltage power data monitoring and waveform interactive analysis system according to claim 2, characterized in that, The multi-port high-concurrency server unit is coupled with the application runner interface of the Spring Boot framework, and the network service initialization is triggered by the framework startup completion signal; among them, (1) after the Netty server receives the startup instruction, it first dynamically detects the number of CPU cores N of the host machine, and constructs the main control thread group and the worker thread group according to the ratio of 1 × N and 2 × N respectively, and uses the independent worker thread Netty server thread to carry all Netty event loops to ensure that the business thread and the input / output thread are physically isolated; (2) the Netty server has a built-in waveform unique identifier table with a length of 20, and each unique identifier corresponds to a physical listening port; during the startup process, the server uses a countdown lock with an initial value of 20 as a synchronization barrier to execute the server bootloader binding process 20 times in a loop; The channel mapping unit is based on a concurrent hash mapping table, where the key is an integer waveform unique identifier and the value is the channel processing context, so as to realize bidirectional mapping management between the waveform unique identifier and the Netty channel; The working process of the waveform parsing and high-speed forwarding unit includes a connection establishment phase, a data reception and parsing phase, and an exception and disconnection handling phase. Among them, (1) in the connection establishment phase, when the client handshake successfully triggers the channel activation event, the Netty server first verifies the validity of the unique identifier of the waveform data and the channel registry instance; after verification, it calls the registration method to register the channel and attempts to start the high-performance ring buffer manager, and then outputs the handshake success log; (2) in the data reception and parsing phase, the channel read only receives byte buffer type messages, and all other types are recorded as alarms and discarded; multiplexing line The floating-point list of local variables in the process is used as a data buffer of length 1024 to avoid frequent heap allocation; the method of parsing floating-point numbers from the byte buffer is called to parse 1024 floating-point numbers in little-endian order, and if the data is insufficient, it is automatically filled with zeros; after parsing, an immutable list is copied out, and the data push method is called to realize zero-lock publishing; the byte buffer is released uniformly in the final execution block to prevent off-heap memory leaks; (3) In the above exception and disconnection handling stage, when an exception is captured or the channel is deactivated, the Netty server first records detailed logs, then calls the cancellation method to remove the channel mapping, and finally closes the connection to ensure complete recycling of system resources.

4. The high-voltage power data monitoring and waveform interactive analysis system according to claim 2, characterized in that, The event-driven layer includes an event object unit, an event factory unit, an event processing unit, and an event scheduling management unit. The event object unit constructs data events carrying a unique identifier, a system nanosecond timestamp, and a floating-point list container. The event factory unit pre-fills 4096 slots. The event processing unit uses a waveform data processor and listeners for concurrent consumption. The event scheduling management unit uses lazy loading & singleton startup, parallel partitioning strategies, and listener registration / destruction to drive continuous output from the circular buffer, sending the scheduled high-voltage power waveform data into the business processing layer.

5. The high-voltage power data monitoring and waveform interactive analysis system according to claim 4, characterized in that, In the event object unit, (1) the data event object adopts the format of waveform data unique identifier + current timestamp + data container object triplet, wherein the data container object pre-allocates a floating-point list of length 1024 and declares it as a final immutable reference to avoid runtime structure migration; (2) the clearing method only clears the data container list and does not reset the waveform data unique identifier. Combined with Disruptor's object pool reuse strategy, it significantly reduces the pressure of heap memory allocation and garbage collection in high-frequency writing scenarios. The event factory unit is used to implement the event factory interface. During the Disruptor initialization phase, it is responsible for creating data object instances in batches for the full-length slots of the circular buffer, ensuring that existing objects are always reused in the subsequent release phase. In the event processing unit, (1) a unique identifier for the exclusive waveform data is passed into the construction parameters, and the waveform identifier in the event is compared in the first line of the event callback; if they do not match, the process will terminate early to ensure data isolation when multiple processors in the same ring buffer are running in parallel; (2) the processor holds a list of event listeners, and the trigger data is traversed and the callback is reached only when the data container is not empty; a single listener call is wrapped by capturing exceptions, and any single point of exception will not affect other listeners in the same batch; (3) regardless of the processing result, the event object cleanup method is called in the final block to reclaim the list capacity in time for reuse in the next cycle; In the event scheduling management unit, (1) only an empty mapping table is created when the system starts; when the event push method arrives for the first time and the circular buffer does not exist, the Disruptor is called to dynamically load the corresponding Disruptor and event handler, reducing the cost of cold start; (2) atomic boolean variables are used to double-check in the global startup method and the event push to ensure that the Disruptor is only started once in the multi-threaded concurrent scenario; (3) a Disruptor instance and a circular queue buffer are independently allocated for each waveform unique identifier, without locking each other, to achieve concurrent writing and consumption of twenty data channels; (4) the event is published and the event is written; the entire publishing process only involves pointer movement and memory writing, without locks, copying, or context switching; (5) Publicly add / remove data event listeners, and use a write-on-write copy list to save the UI and time-series database to ensure safe concurrent read and write operations and a performance balance of fewer writes and more reads.

6. The high-voltage power data monitoring and waveform interactive analysis system according to claim 1, characterized in that, The business processing layer includes a waveform object dispatch unit, which performs robust filtering, listener broadcasting, and event reset processing on the scheduled high-voltage power waveform data. Subsequently, the processed high-voltage power waveform data is distributed to a real-time push channel and an asynchronous time-series data persistence channel. Within the real-time push channel, the processed high-voltage power waveform data is transmitted to the front-end rendering layer through precise subscription filtering, thread pool, and instruction feedback. Within the asynchronous time-series data persistence channel, the processed high-voltage power waveform data of the same batch is written into the time-series database through list assignment & serialization, task submission and asynchronous writing, and lifecycle management is completed through a data eviction mechanism.

7. The high-voltage power data monitoring and waveform interactive analysis system according to claim 6, characterized in that, In the waveform object dispatch unit, (1) First, compare the unique identifier of the waveform. If they do not match, immediately terminate early. If they match, check if the data container is empty. If it is empty, discard it. (2) Execute listener broadcast for valid events: call the time-series database listener and the real-time push listener one by one. Each call is wrapped with exception capture to ensure that single point of failure does not spread. After completion, immediately reset the event object. (3) Time-series database listener path: copy the floating-point list and encapsulate it into JSON data points → submit the writing task to the dedicated thread pool → asynchronously write to the specified data bucket to achieve high-throughput persistence. (4) First, filter subscribers in the WebSocket session collection. If there are no subscribers, terminate. If there are, construct a real-time DTO, serialize JSON, and submit the sending task to the WebSocket thread pool. Lock and verify the session inside the task, and then push it to the browser to achieve concurrent and safe millisecond-level updates.

8. The high-voltage power data monitoring and waveform interactive analysis system according to claim 1, characterized in that, The front-end rendering layer includes a rendering receiving unit, a data caching unit, a waveform drawing unit, a user interaction unit, a thread coordination unit, and a state synchronization unit. The rendering receiving unit is responsible for configuring rollback, heartbeat keep-alive, exponential backoff reconnection, and uplink interfaces. The data caching unit constructs a lock-free buffer based on multiple producers, waiting strategies, single consumers, and nanosecond-level publishing. The waveform drawing unit writes the processed high-voltage power waveform data to the canvas in milliseconds using incremental drawing, adaptive frame rate, and switching hooks. The user interaction unit provides waveform switching, history pagination, position adjustment, capture frame placement, waveform downsampling, horizontal and vertical scale adjustment, performance indicator monitoring, and waveform parameter adjustment. The thread coordination unit uses a reconnection scheduling pool and factory threads to manage background tasks. The state synchronization unit completes multi-terminal state synchronization and multi-terminal start / stop.

9. The high-voltage power data monitoring and waveform interactive analysis system according to claim 8, characterized in that, The rendering receiving unit serves the data receiving layer and is softly bound to the configuration attribute file. It obtains instances through a singleton factory, dynamically generates them, and connects to the server. The data caching unit is based on a high-performance lock-free ring buffer framework architecture and is responsible for concurrent buffering and event delivery of the high-voltage waveform data sent by the rendering receiving unit.

Images