CN111290942A - Pressure testing method, device and computer readable medium - Google Patents

Abstract

Embodiments of the present invention provide a stress testing method and a stress testing device. The stress testing method includes: step 1, reading a test case from a test file, and writing it into a first shared memory; step 2, reading a test case from the Read the test case in the first shared memory, generate multiple threads according to the test case, control the multiple threads to send requests to the server under test, and record the request sending time of the multiple threads to the second shared memory In the memory; Step 3, read the request sending time from the second shared memory and receive the request response from the server under test, and organize it into test result data, wherein the steps 1 to 3 are respectively in a thread or execute in the process. The stress testing method asynchronously processes the sending request and the receiving request response, which can avoid the performance bottleneck of the deployment server, thereby avoiding the performance test being affected by the performance bottleneck of the deployment server.

Description

Stress testing method, apparatus and computer readable medium

technical field

The present invention relates to the field of computers, and in particular to a stress testing method, device and computer-readable medium.

Background technique

At present, the mainstream stress testing tools are mainly Loadrunner and Jmeter. The process of using these two tools is to first select the stress test script, then configure the number of concurrent threads, and then click to run the performance test scenario to implement the performance test of the service under test. During the test, each concurrent thread operates the following four steps: 1. Establishing a connection with the service under test 2. Sending request packets 3. Accepting request response packets 4. Repeating steps 1, 2, and 3 continuously. It can be seen from this that these two tools use the method of sending and receiving requests synchronously, so the performance of the stress testing tool may be limited by the performance of the deployment server on which the stress testing tool is deployed, which may cause the stress testing tool performance is not as expected. Further, when the stress testing tool reports performance problems, due to the performance bottleneck of the deployment server, it may be impossible to accurately locate whether the performance problem comes from the service under test itself or from the deployment server.

SUMMARY OF THE INVENTION

In view of this, the embodiment of the present invention provides a stress testing method, which executes the sending request and the receiving request in separate processes or threads, which has solved the performance bottleneck of the deployment server.

According to a first aspect of the present invention, a stress testing method is provided, comprising:

Step 1, read the test case from the test file and write it into the first shared memory;

Step 2: Read the test case from the first shared memory, generate multiple threads according to the test case, control the multiple threads to send requests to the server under test, and record the requests of the multiple threads send time to the second shared memory;

Step 3, read the request sending time from the second shared memory and receive the request response from the server under test, and organize it into test result data,

Wherein, the steps 1 to 3 are respectively executed in respective independent threads or processes.

Preferably, the stress testing method further includes: before generating multiple threads, sending multiple requests to the server under test and receiving request responses, and calculating the number of generated threads and the multiple threads The interval at which requests are sent.

Preferably, the stress test method further includes: writing the test result data into a third shared memory,

The stress testing method further includes: the fourth thread reads the test result data from the third shared memory and writes it into the memory of the monitoring system.

Preferably, the stress testing method further includes: the monitoring system reads the test result data in the memory and displays it on the client interface.

Preferably, the multiple threads are asynchronous threads.

Preferably, the stress testing method further comprises: printing test result data in real time.

Preferably, the stress testing method further includes: calculating performance indicators according to the test result data, and generating a test report.

According to a second aspect of the embodiments of the present invention, a pressure testing device is provided, including:

The use case processing module is used to read the test case from the test file and write it into the first shared memory;

A test execution module, configured to read the test case from the first shared memory, generate multiple threads according to the test case, and control the multiple threads to send requests to the server under test, and record the request sending time into the second shared memory;

A result sorting module, configured to read the request sending time from the second shared memory and receive a request response from the tested server, and sort it into test result data,

Wherein, the use case processing module, the test execution module and the result sorting module are respectively executed in independent threads or processes.

Preferably, the test execution module further includes: before generating multiple threads, sending multiple requests to the server under test and accepting the request responses, and calculating the generated number of the multiple threads and the sending of the multiple threads accordingly. The time interval for the request.

Preferably, the multiple threads are asynchronous threads.

According to a third aspect of the embodiments of the present invention, a computer-readable storage medium is provided, where the computer-readable storage medium stores computer instructions, and when the computer instructions are executed, any one of the above stress testing methods is implemented.

According to a fourth aspect of the embodiments of the present invention, a pressure testing device is provided, including:

memory for storing computer instructions;

A processor, coupled to the memory, configured to execute a stress testing method implementing any of the foregoing based on computer instructions stored in the memory.

An embodiment of the present invention has the following advantages or beneficial effects: the sending request and the receiving request response are processed in different threads or processes, which can avoid the performance bottleneck of the deployment server, thereby avoiding the performance test being affected by the performance bottleneck of the deployment server. . Further, sending requests through multiple threads helps to meet the requirement of sending requests at high frequency.

Further, the test cases in the file are written into the shared memory, and when a request is sent, the test cases are read from the shared memory, avoiding file I/O operations, and helping to meet the performance requirements when sending requests.

Description of drawings

The above and other objects, features and advantages of the present invention will become more apparent from the description of embodiments of the present invention with reference to the following drawings, in which:

1 is a flowchart of a stress testing method according to a first embodiment of the present invention;

2 is a schematic diagram of a stress testing method according to a second embodiment of the present invention;

3 is a schematic diagram of a pressure testing device according to a third embodiment of the present invention;

FIG. 4 is a schematic diagram of a stress testing device according to a fourth embodiment of the present invention.

Detailed ways

The present invention is described below based on examples, but the present invention is not limited to these examples only. In the following detailed description of the invention, some specific details are described in detail. The present invention can be fully understood by those skilled in the art without the description of these detailed parts. In order to avoid obscuring the essence of the present invention, well-known methods, procedures and processes are not described in detail. Additionally, the drawings are not necessarily to scale.

FIG. 1 is a flowchart of a stress testing method according to a first embodiment of the present invention. Specifically, the following steps S101-S103 are included, wherein the steps S101-S103 are respectively executed in three threads or processes. details as follows.

In step S101, the test case is read from the test file and written into the first shared memory.

In step S102, read the test case from the first shared memory, generate multiple threads according to the test case, control the multiple threads to send requests to the server under test, and record the request sending time of the multiple threads to the second shared memory .

In step S103, the request sending time is read from the second shared memory and the request response is received from the server under test, and is organized into test result data.

In this embodiment, the test file includes multiple test cases. Each test case includes, for example, information such as the set time, the number of requests, and the content of the request, that is, by sending a set number of requests at the set time and determining the performance indicators of the service under test according to the request results.

In this embodiment, the first thread or process is used to write all the test cases in the test file into the first shared content, and then the second thread or process is used to read the test cases from the first shared memory, and generate Multiple threads, each thread sends several requests, and records the request log of each thread in the second shared memory. The request log contains the request sending time and the thread ID that sent the request. The test server receives the request response, reads the request log from the second shared memory, and organizes the request log and the request response information into test result data. Therefore, asynchronous processing of request sending and receiving requests is implemented, which avoids the problem of untimely processing caused by the performance bottleneck of the deployment server, thereby avoiding the performance test of the service under test from being affected by the performance bottleneck of the deployment server. Further, writing the test case to the shared memory, and reading the test case from the shared memory when a request is sent, avoids file I/O operations, which helps to meet the performance requirements of the request. At the same time, sending requests through multiple threads helps to meet the needs of high-frequency sending requests.

FIG. 2 is a schematic diagram of a stress testing method according to a second embodiment of the present invention.

Referring to FIG. 2, in module 201, thread 1-1 is created, and thread 1-1 executes steps S301 and S302 in sequence. S301 reads data from the test file 2011 , and step S302 writes the data into the shared memory 2012 . In module 202, step S401 is first performed, and step S401 reads data from the shared memory 2012, and then step S402 is performed. Step S402 calculates the number and time interval of generating threads according to the read data and the set rules. N threads. Steps S403 and S404 are then executed respectively, that is, a request is sent to the service under test on the server 300 , and the request sending time is recorded to the shared memory 2021 . In module 203, thread 1-2 is created, and thread 1-2 executes step S405, that is, reads data from the shared memory 2012, and executes steps S406 and S407, that is, receives the request and returns, and records the request response time, which will be sorted out The test result data is written to the shared memory 2022. In module 204, thread 1-3 is created, thread 1-3 executes step S408, that is, reads data from the shared memory 2022 regularly, and executes step S409, that is, writes the data to the memory 2023, and the monitoring system 205 reads it from the memory 2023 Get the data and display it on the client interface. It should be noted that, in order to achieve the effect of the stress test in the embodiment of the present invention, the modules 201, 202, and 203 are preferably executed in respective independent threads or processes.

In the above embodiment, the shared memory 2022 is used to store the test result data. Optionally, the module 203 can also generate a test report from the test result data. Optionally, the module 203 can also collect performance indicators such as AVG, TP50, TP90, TP99, TP999, the number of calls, and the number of errors as part of the test result data. AVG is the average memory or CPU usage. TP50 refers to counting the time consumed by each invocation of the method in a period of time (such as 5 minutes), sorting these times in ascending order, and taking the 50th percentile value as the TP50 value; configure this After monitoring the alarm threshold corresponding to the indicator, it is necessary to ensure that at least 50% of the consumption time of all calls of the method within this time period is less than this threshold, otherwise the system will alarm. TP90, TP99, TP999 and TP50 are calculated in the same way. They represent different performance requirements of the method. TP50 is relatively low, TP90 is relatively high, and TP99 and TP999 have high requirements for method performance.

Modules 201, 202 and 203 make up the test tool and are usually deployed on the same server. The server is the deployment server described in the background art. The service under test is usually deployed on another server. According to the embodiment of the present invention, the stress test can be completed only by regularly updating the test file without writing a stress test script, thereby reducing the work pressure of the tester.

FIG. 3 is a schematic diagram of a stress testing device according to a third embodiment of the present invention. The stress testing apparatus 300 includes a use case processing module 301 , a test execution module 302 , a result sorting module 303 and a creation module 304 . The creation module 304 is used to create three threads or processes, so that other modules are executed in an independent thread or process respectively. Of course, the creation module 304 itself can be either a single thread or a single process, or a multi-thread or multi-process. When the creation module 304 is a single thread or a single process, it is responsible for the control of the entire process, and may also be responsible for reading some configuration information and resource recycling. When the creation module 304 is a multi-process or multi-thread, the work it is responsible for is allocated to different processes or threads.

The use case processing module 301 is configured to read the test case from the test file and write it into the first shared memory.

The test execution module 302 is configured to read test cases from the first shared memory, generate multiple threads according to the test cases, and control the multiple threads to send requests to the server under test, and record the request sending time to the second shared memory .

The result sorting module 303 is configured to read the request sending time from the second shared memory, receive the request response from the server under test, and sort it into test result data.

In one embodiment, the above-mentioned stress testing apparatus 300 further includes: a computing module, configured to send multiple requests to the service under test and receive request responses, and calculate the number of generated threads and the number of threads sent by multiple threads accordingly. time interval. The calculation module can be executed in the thread or process where the test execution module 302 is located, or can be executed in the thread or process where the creation module 304 is located.

In one embodiment, the multiple threads created by the test execution module 302 are asynchronous threads. After an asynchronous thread sends a request, it does not have to wait for the request response, so it can send the request and receive the request response in different threads or processes.

FIG. 4 is a schematic diagram of a stress testing device according to a fourth embodiment of the present invention. The device shown in FIG. 4 is only an example, and should not constitute any limitation on the function and scope of use of the embodiments of the present invention.

Referring to FIG. 4 , the apparatus includes a processor 401 , a memory 402 and an input and output device 403 connected by a bus. The memory 402 includes read-only memory (ROM) and random access memory (RAM). Various computer instructions and data required to perform system functions are stored in the memory 402. The processor 401 reads various computer instructions from the memory 402 to execute. Various appropriate actions and handling. Input and output devices include input sections such as keyboards, mice, etc.; output sections such as cathode ray tubes (CRTs), liquid crystal displays (LCDs), etc. and speakers, etc.; storage sections including hard disks, etc.; The communication part of the network interface card. The memory 402 also stores the following computer instructions to complete the operations specified by the device of the embodiment of the present invention: Step 1, read the test case from the test file, and write it into the first shared memory; Step 2, read the test case from the first shared memory; Read the test case in a shared memory, generate multiple threads according to the test case, control the multiple threads to send requests to the server under test, and record the request sending time of the multiple threads to the second shared memory in; Step 3, read the request sending time from the second shared memory and receive the request response from the server under test, and organize it into test result data, wherein the steps 1 to 3 are respectively in the respective independent threads or in-process execution.

Correspondingly, an embodiment of the present invention provides a computer-readable storage medium, where computer instructions are stored in the computer-readable storage medium, and when the computer instructions are executed, the operations specified in the foregoing method are implemented.

The flowcharts and block diagrams in the accompanying drawings illustrate the possible architecture, functions, and operations of the systems, methods, and devices of the embodiments of the present invention, and the blocks on the flowcharts and block diagrams may represent a module, a program segment, or just a segment. Code, the modules, program segments and codes are all executable instructions for implementing specified logical functions. It should also be noted that the executable instructions implementing the specified logical functions may be recombined to create new modules and program segments. Therefore, the blocks and the block sequence of the drawings are only used to better illustrate the process and steps of the embodiment, and should not be taken as a limitation on the invention itself.

Each module or unit of the system can be implemented by hardware, firmware or software. The software includes, for example, coding programs formed in various programming languages such as JAVA, C/C++/C#, and SQL. Although the steps and sequence of the steps in the embodiments of the present invention are given in the method and the method illustration, the executable instructions for implementing the specified logical functions of the steps may be recombined to generate new steps. The sequence of the steps should not be limited only to the sequence of steps in the method and the method legend, and can be adjusted at any time according to functional requirements. For example, certain steps characterized by are performed in parallel or in reverse order.

Systems and methods according to the present invention may be deployed on a single or multiple servers. For example, different modules can be deployed on different servers to form dedicated servers. Alternatively, the same functional unit, module or system can be deployed distributed across multiple servers to reduce load pressure. The servers include, but are not limited to, multiple PCs, PC servers, blade machines, supercomputers, etc. connected in the same local area network and through the Internet.

The above descriptions are only preferred embodiments of the present invention, and are not intended to limit the present invention. For those skilled in the art, the present invention may have various modifications and changes. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention shall be included within the protection scope of the present invention.

Claims (12)

1. A pressure testing method, comprising:

step 1, reading a test case from a test file, and writing the test case into a first shared memory;

step 2, reading the test case from the first shared memory, generating a plurality of threads according to the test case, controlling the plurality of threads to send requests to a tested server, and recording sending logs to a second shared memory;

step 3, reading the sending log from the second shared memory, receiving a request response from the tested server, and arranging the request response into test result data,

wherein, the steps 1 to 3 are executed in one thread or one process respectively.

2. The pressure testing method of claim 1, further comprising:

before generating a plurality of threads, sending a plurality of requests to the tested server and receiving request responses, and accordingly determining the generation quantity of the plurality of threads and the time intervals of sending the requests by the plurality of threads.

3. The pressure testing method of claim 1, further comprising:

writing the test result data into a third shared memory; and

and reading the test result data from the third shared memory and writing the test result data into the memory of the monitoring system.

4. The pressure testing method of claim 3, further comprising:

and the monitoring system reads the test result data in the memory and displays the test result data on a client interface.

5. The stress testing method of claim 1, wherein the plurality of threads are all asynchronous threads.

6. The pressure testing method of claim 1, further comprising: and printing the test result data in real time.

7. The pressure testing method of claim 1, further comprising: and calculating the performance index according to the test result data and generating a test report.

8. A pressure testing device comprising:

the creating module is used for creating three threads or processes and enabling the use case processing module, the test execution module and the result sorting module to be executed in one thread or process respectively;

the case processing module is used for reading the test cases from the test files and writing the test cases into the first shared memory;

the test execution module is used for reading the test case from the first shared memory, generating a plurality of threads according to the test case, controlling the plurality of threads to send requests to a tested server, and recording request sending time to a second shared memory;

and the result sorting module is used for reading the request sending time from the second shared memory, receiving a request response from the tested server and sorting the request sending time into test result data.

9. The pressure testing apparatus of claim 8, further comprising: and the calculation module is used for sending a plurality of requests to the tested server and receiving the request responses, and calculating the generation quantity of the plurality of threads and the time interval of sending the requests by the plurality of threads according to the request responses.

10. The pressure test apparatus of claim 8, wherein the plurality of threads are asynchronous threads.

11. A computer readable storage medium storing computer instructions which, when executed, implement the pressure testing method of any one of claims 1 to 7.

12. A pressure testing device, comprising:

a memory for storing computer instructions;

a processor coupled to the memory, the processor configured to perform implementing the stress testing method of any of claims 1-7 based on computer instructions stored by the memory.

Images