CN109426601B - A method and device for stateless detection of programs - Google Patents

Abstract

The present disclosure relates to a method and device for stateless detection of a program, and belongs to the technical field of software programming. The method includes: executing the target program after a triggering operation for stateless detection of the target program is detected; if during the execution of the target program, it is detected that a variable of the target program is changed, and the target program is changed. If the variable is not changed by the initial thread established by executing the target program, it is determined that the variable does not conform to the stateless design principle. With the method provided by the embodiment of the present invention, in the process of executing the target program, if it is monitored that the variable of the target program is changed, and the variable is not changed by the initial thread established by executing the target program, it is determined that the variable does not conform to the stateless design in principle. The variables in the target program that do not conform to the stateless design principle are identified from the root cause without manual detection, and the invention realizes the process of automatic detection.

Description

A method and device for stateless detection of programs

technical field

The present disclosure relates to the technical field of software programming, and in particular, to a method and apparatus for stateless detection of a program.

Background technique

The concept of REST (Representational State Transfer) was first proposed in Roy Fielding's doctoral dissertation "Architectural styles and the design of network-based software architectures" in 2000. , REST is proposed for the program based on network service, wherein, the program based on network service refers to the program executed by the server in response to the request of the client. REST describes the constraints and design principles of the program design architecture. If the design architecture of a program conforms to the constraints and design principles of REST, then the design architecture of the program is a RESTful architecture. A program with a RESTful architecture is more concise than a general program, and it is easier to implement mechanisms such as caching in the interaction between the client and the server.

To implement a RESTful architecture, it is necessary to meet the five constraints and design principles required for RESTful architecture design. Among the above five constraints and design principles, the most important one, which is also the focus of this article, is that all operations in the server are stateless. If the above conditions are met, the stateless design principle is also met.

The so-called stateless design principle means that the server cannot store any client state-related information such as user name and password information. Each request that the client initiates to the server is independent and cannot rely on previous requests. Each request from the client to the server should contain all the information the server needs to process the request. Therefore, all the state-related information of the client should be stored on the client. Each time the client sends a request to the server, the client's state-related information is sent again, and the server does not need to store any client's state-related information. In this way, the memory space of the server can be saved, and when a server fails, the failed server can be quickly replaced with another backup server, and the client can continue to communicate with the backup server normally. From the above, we can see that it is very important that the program can meet the principle of stateless design.

In the process of realizing the present disclosure, the inventor found at least the following problems:

After the programmer has written a program, how to perform stateless detection of the program? In other words, how do you know if your program meets the stateless design principles? Or, does the old program written in the past satisfy the principle of stateless design? In the prior art, the code is checked line by line manually. However, for large-scale program code, manual inspection is unreliable.

SUMMARY OF THE INVENTION

In order to overcome the problems existing in the related art, the present disclosure provides the following technical solutions:

A first aspect provides a method for stateless detection of a program, the method comprising: after detecting a trigger operation for stateless detection of a target program, executing the target program; if in the process of executing the target program, monitoring If the variable to the target program changes, and the variable is not changed by the initial thread established by executing the target program, it is determined that the variable does not conform to the stateless design principle.

With the method provided by the embodiment of the present invention, in the process of executing the target program, if it is monitored that the variables of the target program are changed, and the variables are not changed by the initial thread established by executing the target program, it is determined that the variables do not conform to the stateless design. in principle. The variables in the target program that do not conform to the stateless design principle are identified from the root cause without manual detection, and the invention realizes the process of automatic detection.

In a possible implementation manner, monitoring whether the variables of the target program are changed includes: monitoring whether the variables are changed through the JVMTI interface.

Variables can be monitored for changes through the JVMTI interface. The JVMTI interface is the native programming interface of the Java virtual machine. If the JVMTI interface is used, it involves the content of the C (a programming language) layer at the bottom of the Java virtual machine and the JNI (Javanative interface, Java native interface) interface. In practical applications, an agent agent method can be established to use the JVMTI interface. The agent method can use the functions of the JVMTI interface, set the callback function, and obtain the running state information of the current thread from the Java virtual machine. operation in the running state.

In a possible implementation manner, judging whether the variable is changed by the initial thread established by executing the target program includes: determining a judgment method corresponding to the variable according to the variable type to which the variable belongs, and judging whether the variable is changed according to the judgment method. Changed by the initial thread, wherein the judgment method is a method for judging whether the variable is changed by the initial thread.

According to the variable type of the variable, the method corresponding to the variable is determined to determine whether the variable has been changed by the initial thread.

In one possible implementation, the variable types include static variables and member variables.

In specific application scenarios, because the variables corresponding to different variable types have different characteristics in use, for example, static variables may be modified by the global program, while member variables may only be modified by objects and will be destroyed after the object application is completed. Member variables will also be destroyed accordingly. Therefore, different judgment methods are used for different variables to judge whether the variables are changed by the initial thread established by the execution target program.

In a possible implementation manner, the judgment method corresponding to the variable is determined according to the variable type of the variable, and according to the judgment method, it is judged whether the variable is changed by the initial thread, including: if the variable belongs to a static variable, then determine whether the variable is changed with the static variable. The corresponding judgment method is: if the class to which the static variable belongs is not loaded in the initial thread, the static variable is not changed by the initial thread; if the variable belongs to a member variable, the judgment method corresponding to the member variable is determined as: if the member variable belongs to The object is not generated in the initial thread, the member variables are not changed by the initial thread.

According to the variable type of the variable, it is determined whether the variable corresponding to the variable is used to determine whether the variable was changed by the initial thread.

In a possible implementation, if the class to which the static variable belongs is not loaded in the initial thread, the static variable is not changed by the initial thread, including: determining the stack corresponding to the initial thread; if the static variable is not found in the stack If the class to which the static variable belongs, the class to which the static variable belongs is not loaded in the initial thread, and the static variable is not changed by the initial thread; if the object to which the member variable belongs is not generated in the initial thread, the member variable is not changed by the initial thread, including : Determine the label bound to the object to which the member variable belongs. If there is no label in the list of labels attached by the initial thread, the object to which the member variable belongs is not generated in the initial thread, and the member variable is not changed by the initial thread.

According to the variable type of the variable, it is determined whether the variable corresponding to the variable is used to determine whether the variable was changed by the initial thread. For static variables, when the target function is executed, the class to which the static variable belongs is directly loaded into the stack corresponding to the initial thread, ready to be called. Therefore, if the class of the static variable is not found on the stack corresponding to the initial thread, the class to which the static variable belongs is not loaded in the initial thread, and the static variable is not changed by the initial thread. It is very likely that the static variable was changed by the client thread. For member variables, when a change is detected in the member variable, the label bound to the object to which the member variable belongs is determined. If the label does not exist in the label list attached by the initial thread, the object to which the member variable belongs is not in the initial thread. , the member variables were not changed by the initial thread. In a possible implementation, the tag list is stored in the local memory corresponding to the initial thread.

Dedicate a space for the label list to be stored.

In a possible implementation manner, the method further includes: when starting to execute the entry function of the target program, establishing a label list; when detecting that an object creation event occurs during the execution of the target program, binding the created object to Set a label; save the label to the label list.

Provides how to create a list of labels and how to store labels. It is possible to monitor whether an object is created. In the target program, if a statement with the keyword "new" is executed, a new object may be created. When an object creation event is detected, the object can be bound to a tag, and the tag can be stored in the tag list.

In a second aspect, an apparatus for stateless detection of a program is provided. The apparatus includes at least one module, and the at least one module is used to implement the method for executing a task provided in the first aspect.

In a third aspect, a server is provided, the server includes a processor and a memory, the processor is configured to execute instructions stored in the memory; the processor implements the method for executing a task provided in the first aspect by executing the instructions.

In a fourth aspect, a computer-readable storage medium is provided, comprising instructions that, when the computer-readable storage medium runs on a server, cause the server to perform the method described in the first aspect.

In a fifth aspect, there is provided a computer program product comprising instructions, which, when the computer program product is run on a server, cause the server to perform the method described in the first aspect above.

The technical effects obtained by the second to fifth aspects of the above embodiments of the present invention are similar to the technical effects obtained by the corresponding technical means in the first aspect, and will not be repeated here.

The technical solutions provided by the embodiments of the present disclosure may include the following beneficial effects:

With the method provided by the embodiment of the present invention, in the process of executing the target program, if it is monitored that the variables of the target program are changed, and the variables are not changed by the initial thread established by executing the target program, it is determined that the variables do not conform to the stateless design. in principle. The variables in the target program that do not conform to the stateless design principle are identified from the root cause without manual detection, and the invention realizes the process of automatic detection.

It is to be understood that the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the present disclosure.

Description of drawings

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the disclosure and together with the description serve to explain the principles of the disclosure. In the attached image:

FIG. 1 is a schematic structural diagram of a server according to an exemplary embodiment;

FIG. 2 is a flowchart of a method for performing stateless detection on a program according to an exemplary embodiment;

3 is a schematic flowchart of a stateless detection of a program according to an exemplary embodiment;

FIG. 4 is a schematic diagram of an application for performing stateless detection on a program according to an exemplary embodiment;

FIG. 5 is a schematic diagram of an apparatus for performing stateless detection on a program according to an exemplary embodiment;

Fig. 6 is a schematic diagram of an apparatus for performing stateless detection on a program according to an exemplary embodiment.

The above-mentioned drawings have shown clear embodiments of the present disclosure, and will be described in more detail hereinafter. These drawings and written descriptions are not intended to limit the scope of the disclosed concepts in any way, but rather to illustrate the disclosed concepts to those skilled in the art by referring to specific embodiments.

Detailed ways

Exemplary embodiments will be described in detail herein, examples of which are illustrated in the accompanying drawings. Where the following description refers to the drawings, the same numerals in different drawings refer to the same or similar elements unless otherwise indicated. The implementations described in the illustrative examples below are not intended to represent all implementations consistent with this disclosure. Rather, they are merely examples of apparatus and methods consistent with some aspects of the present disclosure as recited in the appended claims.

An embodiment of the present invention provides a method for stateless detection of a program, and the execution body of the method may be a server.

FIG. 1 is a block diagram of a server 1900 according to an exemplary embodiment. 1, the server 1900 includes a processor 1922, and memory resources, represented by memory 1932, for storing instructions executable by the processor 1922, such as application programs. An application program stored in memory 1932 may include one or more modules, each corresponding to a set of instructions. Additionally, the processor 1922 is configured to execute instructions to perform a method of stateless detection of a program.

The server 1900 may also include a power supply assembly 1926 configured to perform power management of the server 1900, a wired or wireless network interface 1950 configured to connect the server 1900 to a network, and an input output (I/O) interface 1958. Server 1900 may operate based on an operating system stored in memory 1932, such as Windows Server™, Mac OS X™, Unix™, Linux™, FreeBSD™ or the like.

Server 1900 may include memory 1932, and one or more programs, wherein one or more programs are stored in memory 1932.

An exemplary embodiment of the present disclosure provides a method for stateless detection of a program. As shown in FIG. 2 , the processing flow of the method may include the following steps:

Step S210, after detecting a trigger operation for stateless detection of the target program, execute the target program.

The target program refers to a program that needs to perform stateless detection, and the target program is generally programmed by Java (an object-oriented programming language).

In the embodiment of the present invention, the target program is run, and during the running process of the target program, the running status of the target program is monitored to find out the relevant code in the target program that violates the principle of stateless design. After running the entire target program, the problems found during the running of the target program will be output in the report one by one to prompt the programmer where the problem lies. In the report, you can identify the file and line number where the code that caused the problem is located.

Step S220, if it is detected that the variable of the target program is changed during the execution of the target program, and the variable is not changed by the initial thread established by executing the target program, it is determined that the variable does not conform to the stateless design principle.

In the server 1900, when the server 1900 executes the target program, it will establish a corresponding initial thread to execute the target program. A server 1900 generally corresponds to multiple clients. When each client sends a request to the server 1900, a client thread is specially established in the server 1900 for each request to process the requests. Since the threads can interact, the client thread can modify the data in the initial thread of the server 1900, such as the variables in the running of the target program. When the design architecture of the program of the server 1900 does not meet the stateless design principle, the server 1900 needs to store the state-related information of the client, then the client thread needs to change the state-related information used to store the client in the initial thread of the server 1900 variable, and a cross-thread variable change event will be generated. Therefore, the embodiments of the present invention detect the above-mentioned cross-thread variable change event to monitor variables in the target program that do not conform to the principle of stateless design.

In the implementation, when starting to execute the entry function of the target program, using the code injection technology, without changing the original target program, the code corresponding to the method described in this embodiment can be injected into the target program, so that the target program can be injected into the target program. While the program is executing, the target program is monitored.

Optionally, the step of monitoring whether a variable of the target program changes includes: monitoring whether the variable changes through a JVMTI (JVM ToolInterface, Java Virtual Machine Tool) interface.

The JVMTI interface is a native programming interface provided by the Java virtual machine, and is an updated version of JVMPI (Java Virtual Machine Profiler Interface, Java Virtual Machine Analysis Interface) and JVMDI (Java Virtual Machine Debug Interface, Java Virtual Machine Debug Interface). It can be known from the development history of the JVMTI interface that the JVMTI interface provides the function of analyzing and debugging Java programs. At the same time, in the fifth version of Java, the JVMTI interface also adds functions such as Monitoring, Thread analysis, and Coverage Analysis. The power of the JVMTI interface enables the implementation of some Java debuggers and other Java runtime testing and analysis tools.

The JVMTI interface is the native programming interface of the Java virtual machine. If the JVMTI interface is used, the C layer at the bottom of the Java virtual machine and the content of the JNI interface are involved. In practical applications, an agent agent method can be established to use the JVMTI interface. The agent method can use the functions of the JVMTI interface, set the callback function, and obtain the running state information of the current thread from the Java virtual machine. operation in the running state.

In the implementation, when the target program is executed, the classes in the target program are loaded, and the variables in the classes can be monitored through the JVMTI interface. As shown in Figure 3, in the Java layer, the target program starts to execute from the entry function. In the C layer, whether the variables in the target program are changed in real time is monitored through the JVMTI interface. When a variable is detected, the changed variable is sent to the recognizer in the stateless detection recognition engine through the JVMTI interface. In the identifier, it can be judged whether the changed variable is changed by the initial thread established by executing the target program, and it can be determined that the variable identifier does not conform to the principle of stateless design.

It should be noted that, during the specific execution of the above method, the server 1900 first loads the content of the C layer, and then loads the content of the Java layer.

Optionally, there are multiple variables, and there should be different monitoring and processing methods for different variable types. Correspondingly, the step of judging whether the variable is changed by the initial thread established by the execution target program comprises: according to the variable type to which the variable belongs, determining a judgment method corresponding to the variable, and according to the judgment method, judging whether the variable is changed by the initial thread, Among them, the judgment method is a method for judging whether the variable is changed by the initial thread.

Optionally, variable types include static variables and member variables.

It should be noted that, in specific application scenarios, the variables corresponding to different variable types have different characteristics in use. For example, static variables may be modified by the global program, while member variables may only be modified by objects. After that, it will be destroyed, and the member variable will also be destroyed. Therefore, different judgment methods are used for different variables to judge whether the variables are changed by the initial thread established by the execution target program. The following describes how to judge whether the variable is changed by the initial thread established by the execution target program for the two types of variables: static variable and member variable:

Optionally, according to the variable type of the variable, determine the judgment mode corresponding to the variable, and according to the judgment mode, the steps of judging whether the variable is changed by the initial thread include:

First, if the variable is a static variable, the judgment method corresponding to the static variable is determined as follows: if the class to which the static variable belongs is not loaded in the initial thread, the static variable is not changed by the initial thread.

In implementation, when it is detected that the variable is changed, the variable type described by the changed variable can be determined next, and if it is a static variable, it is determined whether the class to which the static variable belongs is loaded in the initial thread.

Secondly, if the variable belongs to a member variable, the judgment method corresponding to the member variable is determined as follows: if the object to which the member variable belongs is not generated in the initial thread, the member variable is not changed by the initial thread.

In the implementation, when a change of a variable is detected, the variable type described by the changed variable is still judged, and if it is a member variable, it is judged whether the object to which the member variable belongs is generated in the initial thread.

Optionally, the method provided next can be used to determine whether the class to which the static variable belongs is loaded in the initial thread or whether the object to which the member variable belongs is generated in the initial thread.

Correspondingly, if the class to which the static variable belongs is not loaded in the initial thread, the steps that the static variable is not changed by the initial thread include: determining the stack corresponding to the initial thread; if the class to which the static variable belongs is not found in the stack, then The class to which the static variable belongs is not loaded in the initial thread, and the static variable is not changed by the initial thread.

In implementation, when the target function is executed, the class to which the static variable belongs is directly loaded into the stack corresponding to the initial thread to prepare to be called. Therefore, if the class of the static variable is not found on the stack corresponding to the initial thread, the class to which the static variable belongs is not loaded in the initial thread, and the static variable is not changed by the initial thread. It is very likely that the static variable was changed by the client thread. When the client thread changes the static variable, first the client thread will load the class to which the static variable belongs to its own stack. The static variable has the property of being read and written by different threads. Furthermore, the static variable does not conform to the principle of stateless design, and the static variable can be output in the detection report. It should be noted that, if the class to which the static variable belongs is not found in the stack, the static variable may also be reported as a low-level error such as WARNING in the detection report. Because, when the class to which the static variable belongs is not loaded in the initial thread, it can be determined that the static variable is not changed by the initial thread. At this time, the static variable can be reported as a high-level error such as ERROR, and when the class to which the static variable belongs Loaded in the initial thread, it is not certain whether the static variable was changed by the initial thread.

If the object to which the member variable belongs is not generated in the initial thread, the member variables are not changed by the initial thread. , the object to which the member variable belongs is not generated in the initial thread, and the member variable is not changed by the initial thread.

Optionally, the tag list is stored in the local memory corresponding to the initial thread.

Optionally, the method provided by this embodiment also includes establishing a label list when starting to execute the entry function of the target program; when detecting that an object creation event occurs in the process of executing the target program, binding the created object to the target program. label; saves the label to the label list.

In implementation, a list of labels is declared when starting to execute the entry function of the target program. The tag list can be declared using data structures such as List and Set provided by Java. After the tag list is declared, the tag list is stored in the local memory corresponding to the initial thread. The local memory is a memory space specially opened up for the initial thread, and is only used by the initial thread. Therefore, it is guaranteed that only the initial thread can operate on the tag list, preventing changes to the tag list by other threads.

Next, it is possible to monitor whether an object is created. In the target program, if a statement with the keyword "new" is executed, a new object may be created. When an object creation event is detected, the object can be bound to a tag, and the tag can be stored in the tag list. It should be noted that the object itself has an identifier, but the identifier is similar to a pointer, and the pointer points to the object. Therefore, with the running of the target program or the running of other threads, the object identification will change from pointing to object A to pointing to object B, or disappear directly, or there are multiple identical object identifications. Therefore, as shown in Figure 3, in order to uniquely identify and track the object in the above situation, when a new object is detected to be created, the object is passed from the Java layer to the JVMTI of the C layer through the JNI interface. interface, and then pass the object to the stateless detection engine through the JVMTI interface to bind the object with a tag in the tag generator.

Finally, when it is detected that the member variable changes, the tag bound to the object to which the member variable belongs is determined. If the tag does not exist in the list of tags attached by the initial thread, the object to which the member variable belongs is not generated in the initial thread. , member variables were not changed by the initial thread. It should be noted that the tag list is dedicated to recording the objects created by the initial thread. When it is found that the object to which the member variable belongs does not have a tag or the bound tag is not in the tag list attached by the initial thread, it is proved that the member variable belongs to The object is not created by the initial thread, then it is most likely created by the client thread, and further, the member variables are not changed by the initial thread.

After step S220 is executed, optionally, it can be determined whether the target program has been executed. If the target program has not been executed, step S220 can be repeatedly executed to run the entire target program and detect all variables in the target program. . After the target program is executed and all variables that do not conform to the stateless design principle are detected, the detected problems can be output in the form of a report to be displayed to the programmer.

Optionally, when establishing the label list, a piece of memory is specially opened for the initial thread as the local memory of the initial thread. The local memory will not be automatically emptied after the execution of the target program, but needs to be manually completed when the target program is about to be executed. Before clearing it, otherwise it will cause a memory leak problem.

As shown in FIG. 4 , the target program running in the server 1900 is a Java program, and the Java simulator supports the Java program, and the Java simulator corresponds to the underlying code translation processing operation, which corresponds to the C layer described above. The entry function of manual input can be put into the Java simulator to tell the Java simulator where to start the stateless detection operation. Through the method provided by the embodiment of the present invention, a piece of code implemented in the C layer can be obtained, and by compiling the code, a corresponding dynamic link library, that is, a .dll file, and a jar (packaged class file) obtained through code injection technology can be obtained. )Bag. At the same time, the dynamic link library and the jar package are added to the startup parameters of the server 1900 to automatically enable the dynamic link library and the jar package. When the server 1900 runs the target program, the code corresponding to the method provided in this embodiment will also run automatically, so as to detect whether the target program conforms to the stateless design principle during the running of the server 1900, and finally output the detection report.

With the method provided by the embodiment of the present invention, in the process of executing the target program, if it is monitored that the variables of the target program are changed, and the variables are not changed by the initial thread established by executing the target program, it is determined that the variables do not conform to the stateless design. in principle. The variables in the target program that do not conform to the stateless design principle are identified from the root cause without manual detection, and the invention realizes the process of automatic detection.

Based on the same technical concept, an embodiment of the present invention also provides a device for stateless detection of a program, as shown in FIG. 5 , the device includes:

The execution module 510 is configured to execute the target program after detecting a trigger operation for stateless detection of the target program.

For a specific implementation manner of the execution module 510, reference may be made to the specific description of step S210 in a method for stateless detection of a program in an embodiment of the present invention.

The determining module 520 is configured to monitor that a variable of the target program is changed during the execution of the target program, and the variable is not changed by the initial thread established by executing the target program, and determine the variable Does not comply with stateless design principles.

For a specific implementation manner of the determination module 520, reference may be made to the specific description of step S220 in a method for stateless detection of a program in the embodiment of the present invention.

Optionally, the determining module 520 is configured to monitor whether the variable is changed through the JVMTI interface.

Optionally, the determining module 520 is configured to determine a judgment mode corresponding to the variable according to the variable type to which the variable belongs, and determine whether the variable is changed by the initial thread according to the judgment mode, Wherein, the judging method is a method for judging whether the variable is changed by the initial thread.

Optionally, the variable types include static variables and member variables.

Optionally, as shown in FIG. 6 , the determining module 520 includes:

The first judgment unit 621 is used to determine that the variable belongs to a static variable, and the judgment method corresponding to the static variable is: if the class to which the static variable belongs is not loaded in the initial thread, the static variable is not changed by the initial thread;

The second judging unit 622 is used to determine that the variable belongs to a member variable, and the judgment method corresponding to the member variable is: if the object to which the member variable belongs is not generated in the initial thread, the member variable is not changed by the initial thread.

Optionally, the first judgment unit 621 is used to determine the stack corresponding to the initial thread; if the class to which the static variable belongs is not found in the stack, the class to which the static variable belongs is not loaded in the stack. In the initial thread, the static variable is not changed by the initial thread;

The second judgment unit is used for 622 to determine the tag bound to the object to which the member variable belongs. If the tag does not exist in the tag list attached by the initial thread, the object to which the member variable belongs is not in the tag list. Generated in the initial thread, the member variable is not changed by the initial thread.

Optionally, the tag list is stored in a local memory corresponding to the initial thread.

Optionally, the device further includes:

establishing a module for establishing the label list when starting to execute the entry function of the target program;

a binding module, used to bind the created object with a label when an object creation event is detected in the process of executing the target program;

The storing module is used for storing the label in the label list.

It should be noted that the above execution module 510 and determination module 520 may be implemented by the processor 1922 , or the processor 1922 may cooperate with the memory 1932 to implement, or the processor 1922 may execute program instructions in the memory 1932 to implement.

With the device provided by the embodiment of the present invention, in the process of executing the target program, if it is monitored that the variables of the target program are changed, and the variables are not changed by the initial thread established by executing the target program, it is determined that the variables do not conform to the stateless design. in principle. The variables in the target program that do not conform to the stateless design principle are identified from the root cause without manual detection, and the invention realizes the process of automatic detection.

It should be noted that: when the device for performing stateless detection on a program provided by the above embodiment performs tasks, only the division of the above functional modules is used as an example for illustration. In practical applications, the above functions can be allocated by different The function module is completed, that is, the internal structure of the server 1900 is divided into different function modules, so as to complete all or part of the functions described above. In addition, the apparatus for stateless detection of a program provided in the above embodiments and the method embodiment for stateless detection of a program belong to the same concept, and the specific implementation process is detailed in the method embodiment, which will not be repeated here.

In the above embodiments, it may be implemented in whole or in part by software, hardware, firmware or any combination thereof, and when implemented in software, it may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions, and when the computer program instructions are loaded and executed on the server 1900, all or part of the processes or functions described in the embodiments of the present invention are generated. The computer instructions may be stored in or transmitted from one computer readable storage medium to another computer readable storage medium, for example, the computer instructions may be downloaded from a website site, computer, server or data center Transmission to another website site, computer, server, or data center by wire (eg, coaxial cable, optical fiber, digital subscriber line) or wireless (eg, infrared, wireless, microwave, etc.). The computer-readable storage medium may be any available medium that can be accessed by the server 1900 or a data storage device such as a server, a data center, or the like that includes an integration of one or more available media. The usable medium may be a magnetic medium (such as a floppy disk, a hard disk, and a magnetic tape, etc.), an optical medium (such as a digital video disk (Digital Video Disk, DVD), etc.), or a semiconductor medium (such as a solid-state disk, etc.).

The above description is only one embodiment of the present invention, and is not intended to limit the present application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application shall be included in the protection scope of the present application. Inside.

Claims (20)

1. A method for stateless detection of a program, the method comprising:

executing the target program after detecting the trigger operation of stateless detection aiming at the target program;

if the change of the variable of the target program is monitored in the process of executing the target program, and if the variable belongs to the member variable, if the object to which the member variable belongs is not generated in the initial thread established by executing the target program, the member variable is not changed by the initial thread, and the member variable is determined not to conform to the stateless design principle.

2. The method of claim 1, wherein monitoring whether a variable of the target program has changed comprises:

and monitoring whether the variable is changed or not through the JVMTI interface.

3. The method according to claim 1 or 2, characterized in that the method further comprises:

if the variable belongs to a static variable, determining a judgment mode corresponding to the static variable as follows: and if the class to which the static variable belongs is not loaded in the initial thread, the static variable is not changed by the initial thread, and the static variable is determined not to conform to a stateless design principle.

4. The method of claim 3,

if the class to which the static variable belongs is not loaded in the initial thread, the static variable is not changed by the initial thread, including:

determining a stack corresponding to the initial thread; if the class to which the static variable belongs is not found in the stack, the class to which the static variable belongs is not loaded in the initial thread, and the static variable is not changed by the initial thread;

if the object to which the member variable belongs is not generated in the initial thread, the member variable is not changed by the initial thread, including:

and determining the label bound by the object to which the member variable belongs, wherein if the label does not exist in a label list attached to the initial thread, the object to which the member variable belongs is not generated in the initial thread, and the member variable is not changed by the initial thread.

5. The method of claim 4, wherein the tag list is stored in a local memory corresponding to the initial thread.

6. The method of claim 4, further comprising:

when starting to execute the entry function of the target program, establishing the tag list;

when an object creating event is detected to occur in the process of executing the target program, the created object is bound with a tag;

and storing the label into the label list.

7. An apparatus for performing stateless detection on a program, the apparatus comprising an execution module and a determination module, the determination module comprising a first determination unit, wherein:

the execution module is used for executing the target program after detecting the trigger operation of the stateless detection aiming at the target program;

the first judging unit is configured to monitor that a variable of the target program is changed in a process of executing the target program, and if the variable belongs to a member variable, if an object to which the member variable belongs is not generated in an initial thread established by executing the target program, the member variable is not changed by the initial thread, and it is determined that the member variable does not conform to a stateless design principle.

8. The apparatus of claim 7, wherein the determining module is configured to monitor whether the variable is changed via a jvm ti interface.

9. The apparatus of claim 7 or 8, wherein the determining module further comprises:

a second determining unit, configured to, if the variable belongs to a static variable, if the class to which the static variable belongs is not loaded in the initial thread, determine that the static variable is not modified by the initial thread, and determine that the static variable does not conform to a stateless design rule.

10. The apparatus according to claim 9, wherein the first determining unit is configured to determine a stack corresponding to the initial thread; if the class to which the static variable belongs is not found in the stack, the class to which the static variable belongs is not loaded in the initial thread, and the static variable is not changed by the initial thread;

the second determination unit is configured to determine a tag bound to an object to which the member variable belongs, and if the tag does not exist in a tag list attached to an initial thread, the object to which the member variable belongs is not generated in the initial thread, and the member variable is not changed by the initial thread.

11. The apparatus of claim 10, wherein the tag list is stored in a local memory corresponding to the initial thread.

12. The apparatus of claim 10, further comprising:

the establishing module is used for establishing the label list when the entrance function of the target program starts to be executed;

the binding module is used for binding the created object with a label when detecting that an object creating event occurs in the process of executing the target program;

and the storing module is used for storing the label into the label list.

13. A server, the server comprising a processor:

the processor is used for executing the target program after detecting the trigger operation of the stateless detection aiming at the target program; if the change of the variable of the target program is monitored in the process of executing the target program, and if the variable belongs to the member variable, and if the object to which the member variable belongs is not generated in an initial thread established by executing the target program, the member variable is not changed by the initial thread, and the member variable is determined not to conform to a stateless design principle.

14. The server according to claim 13, wherein the processor is configured to monitor whether the variable has changed via a jvm ti interface.

15. The server according to claim 13 or 14, wherein the processor is configured to determine that the member variable does not comply with the stateless design rule if the class to which the static variable belongs is not loaded in the initial thread if the variable belongs to a static variable, and the static variable is not modified by the initial thread.

16. The server according to claim 15, wherein the processor is configured to determine a stack corresponding to the initial thread if the variable belongs to a static variable; if the class to which the static variable belongs is not found in the stack, the class to which the static variable belongs is not loaded in the initial thread, and the static variable is not changed by the initial thread; if the variable belongs to the member variable, determining the label bound by the object to which the member variable belongs, if the label does not exist in the label list attached to the initial thread, the object to which the member variable belongs is not generated in the initial thread, and the member variable is not changed by the initial thread.

17. The server according to claim 16, wherein the tag list is stored in a local memory corresponding to the initial thread.

18. The server according to claim 16, wherein the processor is further configured to establish the tag list when starting to execute an entry function of the target program; when an object creating event is detected to occur in the process of executing the target program, the created object is bound with a tag; and storing the label into the label list.

19. A computer-readable storage medium comprising instructions that, when executed on a server, cause the server to perform the method of any one of claims 1-6.

20. A computer program product comprising instructions for causing a server to perform the method of any one of claims 1 to 6 when the computer program product is run on the server.

Images