WO2019006997A1

WO2019006997A1 - Program deadlock detection method, storage medium, device and system

Info

Publication number: WO2019006997A1
Application number: PCT/CN2017/117366
Authority: WO
Inventors: 杨亮; 陈少杰; 张文明
Original assignee: 武汉斗鱼网络科技有限公司
Priority date: 2017-07-01
Filing date: 2017-12-20
Publication date: 2019-01-10
Also published as: CN109213576A; CN109213576B

Abstract

The present invention relates to the field of operating systems, and provides a program deadlock detection method, a storage medium, a device, and a system. The method comprises: S1: adding a hook function into a thread handle creation function, a signal event creation function, a mutex creation function, and a critical region creation function of a thread; S2: obtaining a current thread and a thread ID of the current thread corresponding to the thread handle creation function, the signal event creation function, the mutex creation function, and the critical region creation function by means of the hook function, respectively; S3: storing the obtained thread and thread ID, and resources owned by the obtained thread into a global field; S4: according to the thread ID in the global field, invoking a waiting function of a system to obtain the resources that each thread is waiting for in the global field; S5: selecting any two threads from the global field for deadlock determination. According to the present invention, the deadlock of a program can be effectively detected in a timely manner.

Description

Program deadlock detection method, storage medium, device and system

Technical field

The present invention relates to the field of operating systems, and in particular, to a program deadlock detection method, a storage medium, a device, and a system.

Background technique

An application running in the Windows operating system usually creates multiple threads to share the logic operations of its own runtime, thereby effectively improving the efficiency of the application itself. However, in the multi-threaded computing environment, it is very easy to conflict between threads when reading and writing some global data. For the conflict between threads, the Windows operating system provides a series of thread synchronization and mutual exclusion. Methods to solve the problem of conflicts between threads, for example, signal events, critical sections, mutexes, etc. can be used for thread synchronization and mutual exclusion, but with the use of thread synchronization and mutual exclusion methods, It is the deadlock problem of threads during the running of the application. Deadlock refers to a blocking imagination caused by two or more threads in the process of execution, due to competition of resources or communication between each other. Without other external forces, the thread will remain in the wait state, and the program will be in a deadlock state. These threads that are always waiting for each other are called deadlock threads. If it is not known in time that the program has a deadlock, it is aimed at the program. The effective resolution of the deadlock problem will greatly affect the subsequent operation of the program.

Summary of the invention

Aiming at the defects existing in the prior art, the object of the present invention is to provide a program deadlock detection method, which can timely and effectively determine whether a program has a deadlock. The present invention also provides a program deadlock detection system, which can The program's deadlock is effectively detected, so that the program can be judged in a timely and effective manner.

In order to achieve the above object, the technical solution adopted by the present invention includes:

S1: adding a hook function in the thread handle creation function, the signal event creation function, the mutex creation function, and the critical section creation function of the thread;

S2: When the thread handle creation function, the signal event creation function, the mutex creation function, or the critical section creation function respectively perform thread, signal event, mutex or critical section creation, respectively, the thread function is respectively obtained by the hook function. The current thread corresponding to the function, the signal event creation function, the mutex creation function, and the critical section creation function, and the thread ID of the current thread;

S3: storing the acquired thread, the thread ID, and the resource owned by the acquired thread in the global field;

S4: According to the thread ID in the global field, the calling function of the system is called to obtain the resource waiting for each thread in the global field;

S5: take two threads from the global field, if the resource waiting for the first thread is the resource owned by the second thread, and the resource waiting for the second thread is the resource owned by the first thread , the program has a deadlock, if not, the program does not deadlock.

Based on the foregoing technical solutions, the resources include a memory physical address, a disk sector, a CPU, and an OS resource of an operating system.

Based on the above technical solutions, S2 is specifically:

When the thread handle creates a function to create a thread, the hook function returns the thread handle value returned when the thread is created, the current thread corresponding to the handle creation function, and the thread ID of the current thread.

When the signal event creation function performs signal event creation, the signal event handle value returned by the signal event creation, the current thread corresponding to the signal event creation function, and the thread ID of the current thread are obtained by the hook function;

When the mutex creation function creates the mutex, the hook function returns the mutex handle value returned when the mutex is created, the current thread corresponding to the mutex creation function, and the thread ID of the current thread.

When the critical section creation function creates the critical section, the hook function value returned when the critical section is created, the current thread corresponding to the critical section creation function, and the thread ID of the current thread are obtained by the hook function.

Based on the above technical solutions,

The hook function is also used to join the wait function;

When waiting for the function to run, the hook function is used to get the resources that the thread is waiting for.

Based on the above technical solution, in S4, the information of the resources that the acquired thread waits for is stored in the global dictionary.

The present invention also provides a storage medium having stored thereon a computer program that implements a program deadlock detection method when the computer program is executed by a processor.

The invention also provides a program deadlock detecting device, comprising a memory and a processor, wherein the memory stores a computer program running on the processor, and the processor implements the deadlock detecting method when the computer program executes the computer program .

The invention also provides a program deadlock detection system, comprising:

An injection module for injecting a hook function into a thread's thread handle creation function, a signal event creation function, a mutex creation function, and a critical section creation function;

The obtaining module is configured to respectively use a hook function when the thread handle creation function, the signal event creation function, the mutex creation function, or the critical section creation function respectively perform thread, signal event, mutex or critical section creation Obtaining a thread handle creation function, a signal event creation function, a current thread corresponding to the cipher creation function and the critical section creation function, and a thread ID of the current thread, and the obtaining module is further configured to acquire a resource that the current thread waits for;

a storage module, configured to store the thread and the thread ID acquired by the acquiring module in a global field, where the storage module is further configured to store the resource owned by the acquired thread in the global field;

a judging module, configured to take two threads from the global field, if the resource waiting for the first thread is the resource owned by the second thread, and the resource waiting for the second thread is the first thread If the resource is owned, the program will be deadlocked. If not, the program will not be deadlocked.

On the basis of the above technical solution, the injection module is further configured to inject a hook function into the waiting function of the system, and when the waiting function runs, acquire the resource waiting for the thread through the hook function.

Compared with the prior art, the present invention has the advantages of: injecting a hook function in a thread handle creation function, a signal event creation function, a mutex creation function, and a critical section creation function, respectively acquiring a thread handle creation function by a hook function The signal thread creation function, the mutex creation function, and the current thread corresponding to the critical section creation function and the thread ID of the current thread, thereby quickly and conveniently acquiring the resources owned by the thread and the resources waiting, facilitating timely threading. The judgment of the closed-loop dependency relationship can achieve the purpose of timely learning when the program has a deadlock, and it is convenient to process the deadlock program in time.

DRAWINGS

1 is a flowchart of a method for detecting a program deadlock according to an embodiment of the present invention;

FIG. 2 is a schematic structural diagram of a program deadlock detecting apparatus according to an embodiment of the present invention.

Detailed ways

The present invention will be further described in detail below with reference to the accompanying drawings and embodiments.

Referring to FIG. 1 , an embodiment of the present invention provides a program deadlock detection method, which is used to determine whether a program has a deadlock, a thread synchronization, and a mutual exclusion when a program uses a thread synchronization and mutual exclusion mechanism to perform multi-thread operation. The mechanism includes a signal event, a critical section, a mutex, and a thread handle. The program runs on the Windows operating system, and the program deadlock detection method in the embodiment of the present invention is completed based on the Windows operating system. For a program that has a deadlock, there must be a loop waiting condition. For example, thread P1 is waiting for the resource occupied by one thread P2, and thread P2 is waiting for the resource occupied by one thread P1. In this case, the deadlock of the program will occur. .

For the signal event mechanism, the signal event has two states, one is the signal state, the other is the no signal state, and the thread is waiting for a signal event with no signal state to be blocked. For the current thread, a signal event is created by calling the system's signal event creation function CreateEvent. By waiting for a signal event by calling the wait function WaitForSingleObject, the resource waiting for the current thread can be known.

For the mutex mechanism, the mutex has two states, one is the idle state, and the other is the occupied state. When the thread waits for a mutex of an idle state, the mutex becomes occupied. But the thread will not be blocked, but when a thread waits for a mutex in an occupied state, the thread will be blocked. For the current thread, create a mutex by calling the mutex creation function, and wait for a mutex through the system call wait function WaitForSingleObject to know the resources waiting for the current thread.

For the critical section mechanism, the critical section has two states, one is the entry state, and the other is the non-entry state. When the thread waits for a critical section that has not entered the state, the critical section becomes the entry state, but the thread does not. It will be blocked, but the thread will be blocked when it waits for a critical section when entering the state. For the current thread, a critical section is created by calling the critical section creation function of the system. By waiting for a critical section by calling the wait function WaitForSingleObject, the resource waiting for the current thread can be known.

For the thread handle mechanism, when a thread is created by calling the thread handle creation function of the system, a thread handle is obtained. Before the created thread is not exited, the thread handle is signalless. When the created thread finishes running, the thread handle becomes changed. It has a signal state.

Resources include memory physical addresses, disk sectors, CPUs, and OS (Operating System) resources of the operating system, that is, hardware resources and software resources to be used during the running of the program.

A program deadlock detection method according to an embodiment of the present invention specifically includes:

S1: Add a hook function (hook function) in the thread handle creation function, the signal event creation function, the mutex creation function and the critical section creation function of the thread, so that the thread handle creation function CreateThread becomes the CreateThreadHook function, the signal event The create function CreateEvent becomes the CreateEventHook function, the mutex creation function CreateMutex becomes the CreateMutexHook function, and the critical section creation function InitializeCriticalSection becomes the InitializeCriticalSectionHook function.

S2: When the thread handle creation function, the signal event creation function, the mutex creation function, or the critical section creation function respectively perform thread, signal event, mutex or critical section creation, respectively, the thread function is respectively obtained by the hook function. The current thread corresponding to the function, signal event creation function, mutex creation function, and critical section creation function, and the thread ID of the current thread.

specific:

When the thread handle creates a function to create a thread, the hook function returns the thread handle value returned when the thread is created, the current thread corresponding to the handle creation function, and the thread ID of the current thread. Because the thread handle creation function CreateThread becomes the CreateThreadHook function, when the program calls the CreateThread function, it will enter the CreateThreadHook function, so through the CreateThreadHook function to get the thread handle value returned when the thread is created, the current thread corresponding to the handle creation function, and The thread ID of the current thread.

When the signal event creation function creates a signal event, the hook event value returned by the signal event creation, the current thread corresponding to the signal event creation function, and the thread ID of the current thread are obtained through the hook function. Because the signal event creation function CreateEvent becomes the CreateEventHook function, when the program calls the CreateEvent function, it will enter the CreateEventHook function, so that the signal event handle value and the signal event creation function corresponding to the signal event creation are obtained through the CreateEventHook function. The current thread and the thread ID of the current thread.

When the mutex creation function creates a mutex, the hook function returns the mutex handle value returned when the mutex is created, the current thread corresponding to the mutex creation function, and the thread ID of the current thread. Because the mutex creation function CreateMutex becomes the CreateMutexHook function, when the program calls the CreateMutex function, it will enter the CreateMutexHook function, and the CreateMutexHook function can be used to obtain the mutex handle value and mutex returned when the mutex is created. Create the current thread corresponding to the function and the thread ID of the current thread.

When the critical section creation function creates the critical section, the hook function value returned when the critical section is created, the current thread corresponding to the critical section creation function, and the thread ID of the current thread are obtained by the hook function. Because the critical section creation function InitializeCriticalSection becomes the InitializeCriticalSectionHook function, when the program calls the InitializeCriticalSection function, it will enter the InitializeCriticalSectionHook function, thereby obtaining the critical section handle value and the critical section creation function returned when the critical section is created by the InitializeCriticalSectionHook function. The current thread and the thread ID of the current thread.

S3: storing the acquired thread, the thread ID, and the resource owned by the acquired thread in the global field ResourctDict, and the resource owned by the thread is the current resource occupied by the thread at runtime;

S4: According to the thread ID in the global field, the system wait function WaitForSingleObject is called to obtain the resource waiting for each thread in the global field, and the resource waiting for the thread is the resource to be used when the thread continues to run. specific:

The hook function is also used to join the wait function WaitForSingleObject; when the wait function WaitForSingleObject is running, the hook function is used to get the resources waiting for the thread. At the same time, the information of the resources that the acquired thread waits for is stored in the global dictionary ResourceWaitDict.

At this point, the resources owned by the thread and the resources waiting for are respectively belonged to the global field and the global dictionary, and are separately saved, so as to facilitate subsequent judgment on whether the program has a deadlock.

S5: take two threads from the global field, if the resource waiting for the first thread is the resource owned by the second thread, and the resource waiting for the second thread is the resource owned by the first thread Then, the program is deadlocked, and the occurrence of the program deadlock phenomenon is detected effectively and timely, thereby facilitating subsequent timely processing. If not, the program does not have a deadlock. That is, in any two threads, the resource waiting for the first thread is the resource owned by the second thread, and the resource waiting for the second thread is the resource owned by the first thread, and the program is deadlocked. If there is no such relationship between any two threads, the program does not have a deadlock.

For example, for thread A and thread B in the global field, thread A waits for a signal event created in thread B, and thread B depends on thread A to exit to set the signal event to a signal state, ie

ResourceDict[hThreadHandleA]=A

ResourceDict[hEvent]=B

And there is

ResourceWaitDict[A]=hEvent

ResourceWaitDict[B]=hThreadHandleA

Therefore, the owner thread of the resource waiting for the thread A is the thread B, and the owner thread of the resource waiting for the thread BA is the thread A. Therefore, the closed loop dependency between the threads is detected, and the program is deadlocked.

The principle of a program deadlock detection method of the present invention lies in the method of injecting a hook function in a thread handle creation function, a signal event creation function, a mutex creation function, and a critical section creation function, when a thread handle creates a function, a signal When the event creation function, the mutex creation function, and the critical section creation function respectively create threads, signal events, mutexes, and critical sections, respectively, the thread handle creation function, signal event creation function, and mutex creation are respectively obtained by the hook function. The current thread corresponding to the function and the critical section creation function and the thread ID of the current thread, thereby quickly and conveniently acquiring the resources owned by the thread and the resources waiting, facilitating the timely judgment of the closed-loop dependency relationship between the threads, thereby obtaining the timely Know whether the program has a deadlock phenomenon, timely judgment, timely processing, and effectively ensure the orderly operation of the program.

In addition, in accordance with the above-described program deadlock detection method, the present invention further provides a storage medium having a computer program stored thereon, and when the computer program is executed by the processor, the steps of the program deadlock detection method described in the above embodiments are implemented. It should be noted that the storage medium includes a U disk, a mobile hard disk, a ROM (Read-Only Memory), a RAM (Random Access Memory), a disk or an optical disk, and the like. The medium of the code.

Referring to FIG. 2, in accordance with the above program deadlock detection method, the present invention further provides a program deadlock detection apparatus, including a memory and a processor, wherein the memory stores a computer program running on the processor, and the processor executes the computer program. The program deadlock detection step of each of the above embodiments is implemented.

The invention also discloses a program deadlock detection system based on the program deadlock detection method, which comprises an injection module, an acquisition module, a storage module and a determination module.

The injection module is used to inject a hook function into the thread's thread handle creation function, the signal event creation function, the mutex creation function, and the critical section creation function; the acquisition module is used when the thread handle creation function, the signal event creation function, and the mutual When the repulsion creation function or the critical section creation function respectively creates threads, signal events, mutexes, or critical sections, respectively, the thread handle creation function, the signal event creation function, the mutexe creation function, and the criticality are respectively obtained by the hook function. The current thread corresponding to the area creation function and the thread ID of the current thread, the obtaining module is further configured to acquire the resource that the current thread waits; the storage module is configured to store the thread and the thread ID acquired by the acquiring module in the global field, The storage module is further configured to store the resources owned by the acquired thread in the global field; the determining module is configured to take two threads from the global field, if the resource waiting for the first thread is the second thread The resources owned, and the resource waiting for the second thread is the resource owned by the first thread, then Sequence deadlock occurs, and if not, then the deadlock does not occur.

The resources include the physical address of the memory, the disk sector, the CPU, and the OS resources of the operating system. At the same time, the injection module is also used to inject a hook function into the system's wait function WaitForSingleObject. When the wait function WaitForSingleObject is running, the hook function acquires the resources that the thread waits for.

The principle of a program deadlock detection system of the present invention is that the injection module injects a hook function into a thread handle creation function, a signal event creation function, a mutex creation function, and a critical section creation function, when a thread handle creation function, The signal event creation function, the mutex creation function, and the critical section creation function respectively acquire the thread handle creation function, the signal event creation function, and the mutex by the hook function when the thread, the signal event, the mutex, and the critical section are respectively created. Create the function and the current thread corresponding to the critical section creation function and the thread ID of the current thread, thereby quickly and conveniently obtaining the resources owned by the thread and the resources waiting, so that the judgment module can timely judge the closed-loop dependency relationship between the threads. Therefore, it is timely to know whether the program has a deadlock imagination, and to obtain time for the subsequent program deadlock processing, and effectively ensure the orderly operation of the program.

The present invention is not limited to the above embodiments, and those skilled in the art can also make several improvements and retouchings without departing from the principles of the present invention. These improvements and retouchings are also considered as protection of the present invention. Within the scope. The contents not described in detail in the present specification belong to the prior art well known to those skilled in the art.

Claims

A program deadlock detection method is used for judging whether a program has a deadlock when a program uses a thread synchronization and mutual exclusion mechanism for multi-thread running, and the thread synchronization and mutual exclusion mechanism includes signal events, critical sections, and mutual The repulsion, and the thread handle, the program runs on the Windows operating system and is characterized by:

S1: adding a hook function in the thread handle creation function, the signal event creation function, the mutex creation function, and the critical section creation function of the thread;

S2: When the thread handle creation function, the signal event creation function, the mutex creation function, or the critical section creation function respectively perform thread, signal event, mutex or critical section creation, respectively, the thread function is respectively obtained by the hook function. The current thread corresponding to the function, the signal event creation function, the mutex creation function, and the critical section creation function, and the thread ID of the current thread;

S3: storing the acquired thread, the thread ID, and the resource owned by the acquired thread in the global field;

S4: According to the thread ID in the global field, the calling function of the system is called to obtain the resource waiting for each thread in the global field;

S5: take two threads from the global field, if the resource waiting for the first thread is the resource owned by the second thread, and the resource waiting for the second thread is the resource owned by the first thread , the program has a deadlock, if not, the program does not deadlock.
The program deadlock detection method according to claim 1, wherein the resources include a memory physical address, a disk sector, a cpu, and an OS resource of an operating system.
A program deadlock detection method according to claim 1, wherein S2 is specifically:

When the thread handle creates a function to create a thread, the hook function returns the thread handle value returned when the thread is created, the current thread corresponding to the handle creation function, and the thread ID of the current thread.

When the signal event creation function performs signal event creation, the signal event handle value returned by the signal event creation, the current thread corresponding to the signal event creation function, and the thread ID of the current thread are obtained by the hook function;

When the mutex creation function creates the mutex, the hook function returns the mutex handle value returned when the mutex is created, the current thread corresponding to the mutex creation function, and the thread ID of the current thread.

When the critical section creation function creates the critical section, the hook function value returned when the critical section is created, the current thread corresponding to the critical section creation function, and the thread ID of the current thread are obtained by the hook function.
A program deadlock detection method according to claim 1, wherein:

The hook function is also used to join the wait function;

When waiting for the function to run, the hook function is used to get the resources that the thread is waiting for.
The program deadlock detection method according to claim 1, wherein in S4, the information of the resource waiting for the acquired thread is stored in the global dictionary.
A storage medium having stored thereon a computer program, wherein the computer program is executed by a processor to implement the method of any one of claims 1 to 5.
A program deadlock detecting apparatus comprising a memory and a processor, wherein the memory stores a computer program running on the processor, wherein the processor executes the computer program to implement any one of claims 1 to 5 Said method.
A program deadlock detection system based on the method of claim 1, comprising:

An injection module for injecting a hook function into a thread's thread handle creation function, a signal event creation function, a mutex creation function, and a critical section creation function;

The obtaining module is configured to respectively use a hook function when the thread handle creation function, the signal event creation function, the mutex creation function, or the critical section creation function respectively perform thread, signal event, mutex or critical section creation Obtaining a thread handle creation function, a signal event creation function, a current thread corresponding to the cipher creation function and the critical section creation function, and a thread ID of the current thread, and the obtaining module is further configured to acquire a resource that the current thread waits for;

a storage module, configured to store the thread and the thread ID acquired by the acquiring module in a global field, where the storage module is further configured to store the resource owned by the acquired thread in the global field;

a judging module, configured to take two threads from the global field, if the resource waiting for the first thread is the resource owned by the second thread, and the resource waiting for the second thread is the first thread If the resource is owned, the program will be deadlocked. If not, the program will not be deadlocked.
A program deadlock detection system according to claim 8, wherein said resources include memory physical addresses, disk sectors, cpus, and OS resources of the operating system.
A program deadlock detection system according to claim 8, wherein said injection module is further configured to inject a hook function into a wait function of the system, and when the wait function is running, acquire a wait by the hook function. Resources.