CN115952167A - Method and device for recording retry in business processing, electronic equipment and storage medium - Google Patents

Abstract

The application provides a method and a device for recording retry in business processing, an electronic device and a storage medium, wherein the method comprises the following steps: acquiring an association record related to a target task to be executed, wherein the association record comprises the current retry times and the current time of a method function corresponding to the target task and the interval duration between the current time and the next execution time; storing the association record to a first preset table, and operating a target task; and moving the association record to a second preset table or a third preset table according to the operation result and the target times acquired after the association record is scanned by the target thread, wherein the target times are values obtained by calling the preset times for the method function based on the interval duration and increasing the preset times for the current retry times. By the method and the device, the problems that in the related technology, retry does not leave traces and retry records cannot be inquired in time subsequently are solved.

Description

Method and device for recording retry in business processing, electronic equipment and storage medium

technical field

The present application relates to the field of computer technology, and in particular to a method and device for recording retry in business processing, electronic equipment and a storage medium.

Background technique

At present, there are some commonly used retry tools, such as the @Retryable annotation provided by the spring framework. This annotation can be marked on the method, so that when the method throws an exception, it will be performed several times after the specified time according to the set delay strategy. Retry;

However, the existing above-mentioned retry methods do not leave relevant records regardless of whether the final method is successfully executed or fails, resulting in the inability to query records in a timely manner.

Therefore, there is a problem in the related technology that the retry does not leave a trace, and the subsequent retry record cannot be queried in time.

Contents of the invention

The present application provides a method and device for recording retries in business processing, electronic equipment, and a storage medium, so as to at least solve the problem in the related art that retries do not leave traces, and subsequent retries cannot be queried in time.

According to an aspect of an embodiment of the present application, a method for recording retry in business processing is provided, the method includes:

Obtain an association record related to the target task to be executed, wherein the association record includes the current number of retries, the current time, and the interval between the current time and the next execution time of the method function corresponding to the target task duration;

storing the associated record in a first preset table, and running the target task;

According to the running result and the target number of times obtained after the target thread scans the associated record, the associated record is moved to the second preset table or the third preset table, wherein the target number of times is based on the interval duration The method function calls a preset number of times, and the value obtained by adding the preset number of times to the current retry times.

According to another aspect of the embodiment of the present application, there is also provided an apparatus for recording retry in business processing, the apparatus includes:

The first acquisition module is configured to acquire an associated record related to the target task to be executed, wherein the associated record includes the current number of retries of the method function corresponding to the target task, the current time, and the relationship between the current time and the next The interval between execution times;

a storage module, configured to store the associated record in a first preset table, and run the target task;

The transfer module is used to move the associated record to the second preset table or the third preset table according to the running result and the target number of times obtained after the target thread scans the associated record, wherein the target number of times is based on The interval duration calls the method function a preset number of times, and the value obtained by adding the preset number of times to the current number of retries.

Optionally, the transfer module includes:

a first transfer unit, configured to move the associated record to the second preset table when the operation result is successful;

An adjustment unit, configured to use the target thread to scan the first preset table successively to obtain target records satisfying preset conditions, call the target records, and adjust The value of the current number of retries recorded by the target;

The second moving unit is configured to move the target record to the third preset table when it is determined that the adjusted value of the current number of retries of the target record is greater than a first preset threshold, wherein the The associated record contains the target record.

Optionally, the adjustment unit includes:

The first obtaining submodule is used to obtain the target record whose next execution time is less than or equal to the current time of the target thread in the associated record;

Adding a submodule, configured to call the target record, and increase the current number of retries of the target record by a first preset value to obtain an intermediate number of retries after the increase of the first preset value.

Optionally, the second transfer unit includes:

The second obtaining submodule is used to obtain the current time of the intermediate number of retries;

A calculation submodule, configured to calculate the next execution time of the target record corresponding to the intermediate retry times according to the current time of the intermediate retry times and the interval duration;

The transfer sub-module is configured to call the target record corresponding to the intermediate retry times when the current time reaches the next execution time of the target record corresponding to the intermediate retry times, until a plurality of the The sum of preset values is the target number of times, and when the target number of times is greater than the first preset threshold, the target record is moved to the third preset table.

Optionally, the device also includes:

The third transfer unit is configured to, after moving the associated record to the third preset table, transfer the third preset table to the third preset table under the condition that the error object in the third preset table is successfully repaired. the reference record where the wrong object has been fixed is moved to said second preset table;

A first setting module, configured to set the current number of retries of the reference record as an initial value state, and set the next execution time of the reference record as the current time;

A triggering module, configured to call the reference record to trigger a retry mechanism when the actual time reaches the current time.

Optionally, the device also includes:

The second setting module is used to set the priority of multiple method functions corresponding to the target task;

A traversal module, configured to traverse the currently acquired associated records in the first preset table;

An execution module, configured to put the associated record where the first method function is located at the tail of the second preset table when it is determined that the priority of the first method function is greater than a second preset threshold , and perform a second preset value reduction operation on the priority of the first method function; if it is determined that the priority of the second method function is equal to the second preset threshold, the second method function Execute the call.

Optionally, the device also includes:

A scanning module, configured to use the target thread to successively scan the first preset table after traversing the currently acquired associated records in the first preset table;

An adding module, configured to continue adding the associations for which priority comparison operations have not been performed when it is determined that the number of priority comparison operations performed on the association records in the first preset table exceeds a third preset threshold Record.

According to yet another aspect of the embodiments of the present application, there is also provided an electronic device, including a processor, a communication interface, a memory, and a communication bus, wherein, the processor, the communication interface, and the memory complete mutual communication through the communication bus; wherein, The memory is used to store a computer program; the processor is used to execute the method steps in any one of the above embodiments by running the computer program stored in the memory.

According to still another aspect of the embodiments of the present application, there is also provided a computer-readable storage medium, in which a computer program is stored, wherein the computer program is set to execute the method in any of the above-mentioned embodiments when running step.

In this embodiment of the application, by obtaining the associated record related to the target task to be executed, wherein the associated record contains the current number of retries, the current time, and the time between the current time and the next execution time of the method function corresponding to the target task the interval time; store the associated record in the first preset table, and run the target task; move the associated record to the second preset table or the third preset table according to the running result and the target number of times obtained after the target thread scans the associated record. Set up a table, wherein the target number of times is the value obtained by calling the method function a preset number of times based on the interval duration and adding the preset number of times to the current retry times. Since the first preset table, the second preset table, and the third preset table are provided in advance in the embodiment of the present application, all associated records are first saved in the first preset table for trace preservation, and then according to the target to be executed The call operation result of the task-related association record and the number of retries of the association record are transferred to the second preset table or the third preset table, so that the retry is preserved regardless of whether it succeeds or fails, so that timely The purpose of querying retry records, accurately locating problems, and improving work efficiency solves the problem of retry leaving no traces in related technologies, and subsequent inability to query retry records in time.

Description of drawings

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

In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the following will briefly introduce the drawings that need to be used in the description of the embodiments or the prior art. Obviously, for those of ordinary skill in the art, In other words, other drawings can also be obtained from these drawings on the premise of not paying creative work.

FIG. 1 is a schematic flowchart of an optional method for recording retry in business processing according to an embodiment of the present application;

Fig. 2 is an optional overall flow chart of completing the record shift table based on the number of retries according to an embodiment of the present application;

Fig. 3 is an optional overall flow chart of completing record shifting table based on retry priority according to an embodiment of the present application;

FIG. 4 is a structural block diagram of an optional device for recording retries in business processing according to an embodiment of the present application;

Fig. 5 is a structural block diagram of an optional electronic device according to an embodiment of the present application.

Detailed ways

In order to enable those skilled in the art to better understand the solution of the present application, the technical solution in the embodiment of the application will be clearly and completely described below in conjunction with the accompanying drawings in the embodiment of the application. Obviously, the described embodiment is only It is an embodiment of a part of the application, but not all of the embodiments. Based on the embodiments in this application, all other embodiments obtained by persons of ordinary skill in the art without creative efforts shall fall within the scope of protection of this application.

It should be noted that the terms "first" and "second" in the description and claims of the present application and the above drawings are used to distinguish similar objects, but not necessarily used to describe a specific sequence or sequence. It is to be understood that the data so used are interchangeable under appropriate circumstances such that the embodiments of the application described herein can be practiced in sequences other than those illustrated or described herein. Furthermore, the terms "comprising" and "having", as well as any variations thereof, are intended to cover a non-exclusive inclusion, for example, a process, method, system, product or device comprising a sequence of steps or elements is not necessarily limited to the expressly listed instead, may include other steps or elements not explicitly listed or inherent to the process, method, product or apparatus.

At present, there are some commonly used retry tools, such as the @Retryable annotation provided by the spring framework. This annotation can be marked on the method function, so that when the method function throws an exception, it will follow the set delay strategy after the specified time. retries, for example:

     

value=Exception.class: When the method throws an exception of type Exception, a retry will be triggered.

maxAttempts=3: retry 3 times.

backoff＝@Backoff(delay＝2000,multiplier＝1.5): The first retry starts after 2 seconds after the method fails, and the retry ends if it succeeds; otherwise, the second retry starts after 2*1.5＝3 seconds and continues to fail Then start the third retry after 3*1.5=4.5 seconds.

However, such tools cannot be consulted again regardless of whether the final method execution succeeds or fails.

In order to solve the above problems, the embodiment of the present application proposes a method for record retry in business processing, as shown in Figure 1, the method can be applied to the server side, the method includes:

Step S101, obtaining an association record related to the target task to be executed, wherein the association record includes the current number of retries, the current time, and the interval between the current time and the next execution time of the method function corresponding to the target task;

Step S102, storing the associated record in the first preset table, and running the target task;

Step S103, move the associated record to the second preset table or the third preset table according to the running result and the target number of times obtained after the target thread scans the associated record, wherein the target number of times is the preset number of calls to the method function based on the interval time. Set the number of times, and add the value obtained by adding the preset number of times to the current number of retries.

Optionally, in the embodiment of this application, the method of annotating the method function is still used:

intervalSecond="5,10,15,20,25,30": means to retry 6 times, the first retry is 5 seconds later, if the failure continues, the second retry is after the first retry fails 10s, and so on.

At the same time, three preset tables are used in advance to complete the retry: the first preset table: ready table, the second preset table: finish table and the third preset table: error table.

At present, the associated records related to the target tasks to be executed are obtained first. When the method functions in these associated records are started to be executed, the method names, method parameters, and current retry times (initialization) corresponding to the program functions in the related records are first 1), the next execution time (the current time is calculated based on the number of retries, for example, the current time is 2011-11-01 08:00:12, and the number of retries is 1, then the next execution time is 2011-11-01 08:00:17) Save it to the ready table, and then start running the target task and executing the method function.

Afterwards, according to the execution result of the method function (which is also the running result of the target task) and the total number of times the method function is retried and called after the target thread in the background continuously scans the associated records in the ready table, move the associated record to to the finish table or error table.

It should be noted that moving the associated record to the finish table or error table needs to be linked to the running result and the number of retries to call the method function. For example, when the method function is successfully executed, the associated record is moved to the finish table. If it is unsuccessful, after the target thread scans the associated record in the ready table, the method function is called the preset number of times based on the interval time, and the current retry count recorded in the associated record is increased by the preset number to obtain the target number of times value to decide whether to move the associated record to the error table.

In addition, there can be one or more target threads. When there is one target thread, each time the method function is called again, the target thread will point to the ready list for scanning; if there are multiple target threads In the case of , each thread is only responsible for scanning the records corresponding to the specific number of retries, that is, when trying to call the method function again, use a new thread to point to the ready table for scanning.

In this embodiment of the application, by obtaining the associated record related to the target task to be executed, wherein the associated record contains the current number of retries, the current time, and the time between the current time and the next execution time of the method function corresponding to the target task the interval time; store the associated record in the first preset table, and run the target task; move the associated record to the second preset table or the third preset table according to the running result and the target number of times obtained after the target thread scans the associated record. Set up a table, wherein the target number of times is the value obtained by calling the method function a preset number of times based on the interval duration and adding the preset number of times to the current retry times. Since the first preset table, the second preset table, and the third preset table are provided in advance in the embodiment of the present application, all associated records are first saved in the first preset table for trace preservation, and then according to the target to be executed The call operation result of the task-related association record and the number of retries of the association record are transferred to the second preset table or the third preset table, so that the retry is preserved regardless of whether it succeeds or fails, so that timely The purpose of querying retry records, accurately locating problems, and improving work efficiency solves the problem of retry leaving no traces in related technologies, and subsequent inability to query retry records in time.

Based on the contents of the above-mentioned embodiments, as an optional embodiment, according to the running result and the target number of times obtained after the target thread scans the associated record, the associated record is moved to the second preset table or the third preset table, including :

If the operation result is successful, move the associated record to the second preset table;

In the case that the operation result is a failure, the target thread is used to scan the first preset table one after another to obtain the target record satisfying the preset condition, execute a call to the target record, and adjust the value of the current number of retries of the target record;

If it is determined that the adjusted value of the current number of retries of the target record is greater than the first preset threshold, the target record is moved to a third preset table, wherein the associated record contains the target record.

Optionally, in the embodiment of the present application, when the operation result is successful, the associated record is moved to the finish table; when the operation result is failure, there is a background target thread that constantly scans the ready table, from the ready table Get the target records that meet the preset conditions, such as getting the records in the associated records whose next execution time is less than or equal to the current time of the target thread, and then try to call the method function in the target record again, you need to add the current time of the target record at the same time Increase the value of the number of retries by increasing the first preset value, such as by 1, to obtain the intermediate number of retries after increasing the first preset value, and calculate the target corresponding to the number of intermediate retries based on the current time and interval of the number of intermediate retries The next execution time of the record.

When the current time reaches the next execution time of the target record corresponding to the number of retries in the middle, execute the call to the target record, so that as long as the method does not end normally, the record in the ready table will not be removed and will be continuously replayed At the same time, increase the number of retries until the number of retries is continuously increased by 1, and the obtained value (that is, the total number of retries) is greater than the first preset threshold, for example, after more than 6 times, the target record will be moved from the ready table to the error table. This completes the retry trace.

In this embodiment of the application, no matter whether the retry is successful or failed, there is a corresponding table to store related records, which is convenient for subsequent query and problem location.

As an optional embodiment, as shown in FIG. 2, FIG. 2 is an optional overall flow chart of completing the record shift table based on the number of retries according to the embodiment of the present application, specifically:

Scan the ready table to get a batch of records whose next execution time is less than or equal to the current time;

determine whether such a record exists;

If it exists, traverse the batch of ready records; if it does not exist, continue scanning;

Determine whether to traverse to the last record;

If it is determined that the current record is the last record, scan the ready table to obtain a batch of records whose next execution time is less than or equal to the current time;

After determining that the current is not the last record, determine whether the number of retries is less than or equal to 6 times;

If it is greater than 6 times, move the record from the ready table to the error table, and recycle multiple records in the ready table; if it is determined to be less than or equal to 6 times, update the execution times and next execution time of the ready record;

According to the recorded method name and method parameters, try to call the method;

If the execution is abnormal, the next ready data is processed; if the execution is successful, the ready record is transferred to the finish table, and the next ready data is recycled.

Based on the contents of the above embodiments, as an optional embodiment, after moving the associated record to the third preset table, the method further includes:

In the case that the error object in the third preset table is successfully repaired, the reference record where the repaired error object in the third preset table is located is moved to the second preset table;

Set the current number of retries of the reference record to the initial value state, and set the next execution time of the reference record to the current time;

In case the actual time reaches the current time, a call is made to the reference record, triggering the retry mechanism.

Optionally, usually the abnormal execution of the method is likely to be caused by a code error. Simply retrying cannot solve the problem, and developers need to modify the code and go online again. However, after the retry of the traditional solution, even if the code is repaired, there is no way Tried again. In the embodiment of this application, the retry information is persisted. If the final retry fails, it is recorded in the error table. After the developer successfully repairs the error object (such as code, etc.) in the error table, he can manually Move the repaired data from the error table to the ready table, and set the number of retries to the initial value state, such as 1, and set the next execution time to the current time, so that when the actual time reaches the current execution time, a retry can be automatically triggered The mechanism is recalled.

In this embodiment of the application, if the final retry fails, after the code is repaired, the retry action can still be triggered again, which solves the problem in the prior art that the code cannot be put into use after an error.

Based on the contents of the foregoing embodiments, as an optional embodiment, the method further includes:

Set the priority of multiple method functions corresponding to the target task;

traversing the associated records in the currently acquired first preset table;

When it is determined that the priority of the first method function is greater than the second preset threshold, the associated record where the first method function is located is placed at the end of the queue of the second preset table, and the priority of the first method function is executed Decrease a second preset value operation; when it is determined that the priority of the second method function is equal to the second preset threshold, call the second method function.

Optionally, in the embodiment of this application, a parameter indicating the retry priority is added to the @Retry annotation. At this time, the priority of multiple method functions corresponding to the target task needs to be set in advance. Here, it can be set as Higher values represent lower priority.

After querying a batch of ready records each time, traverse them one by one. If it is found that there is a method function whose retry priority is greater than the second preset threshold, for example, the priority of the first method function is greater than 1, then the ready record will be The retry priority is reduced by the second preset value, for example, the priority of the first method function is reduced by 1, and at the same time, the associated record where the first method function is located is put back to the end of the queue of this batch of ready records; if the retry priority is equal to 1 , the current method function is executed.

In the embodiment of this application, the retry priority is added, so that when there are a large number of retry tasks, the tasks with higher priority can be executed first to prevent high priority tasks from being blocked by low priority tasks.

Based on the contents of the above-mentioned embodiments, as an optional embodiment, after traversing the associated records in the currently obtained first preset table, the method further includes:

Using the target thread to scan the first preset table successively;

If it is determined that the number of associated records in the first preset table for which priority comparison operations have been performed exceeds a third preset threshold, continue to add associated records for which priority comparison operations have not been performed.

Optionally, in this embodiment of the application, in order to ensure that all associated records in the first preset table implement the operation that the higher the retry priority, the earlier the execution, the embodiment of the application will have a background target thread to successively scan the first A preset table, if it is found that the number of priority comparison operations performed in this batch of ready records exceeds the third preset threshold, for example, after more than half of the number, immediately add a batch of ready records that have not performed priority comparison operations, so that The higher the retry priority, the earlier it will be executed.

In the embodiment of this application, through the setting of retry priority, more retry opportunities are given to high priority methods, which solves the problem that when a large number of time-consuming and unimportant methods in the prior art need to be retried, resulting in subsequent The important method is not getting retried for a long time.

As an optional embodiment, as shown in FIG. 3, FIG. 3 is an optional overall flow chart of completing the record shift table based on the retry priority according to the embodiment of the present application, specifically:

Read 1000 ready records and put them into the queue;

read a task from the queue;

Determine whether the retry priority is greater than 1;

If it is greater than 1, reduce its retry priority by 1, move the ready record to the end of the queue, and then execute the queue read task operation in a loop;

If it is not greater than 1, then judge whether the queue has consumed 500 records;

If so, wake up the filling thread; if not, then determine whether the number of retries is less than or equal to 6 times;

If it is less than or equal to 6 times, update the number of executions and the next execution time of the ready record, and process the next ready record if the execution is abnormal. Otherwise, try to call the method according to the recorded method name and method parameters. If the execution is still successful, the entry The ready records are transferred to the finish table.

Among them, after waking up the filling thread, it is determined that the queue has consumed 500 records, then read 500 ready records and put them into the queue; if it is determined that the queue has not consumed 500 records, set the waiting time (such as waiting for 500s), after reaching the waiting time , loop to determine whether the queue has consumed 500 records.

It should be noted that for the foregoing method embodiments, for the sake of simple description, they are expressed as a series of action combinations, but those skilled in the art should know that the present application is not limited by the described action sequence. Depending on the application, certain steps may be performed in other orders or simultaneously. Secondly, those skilled in the art should also know that the embodiments described in the specification belong to preferred embodiments, and the actions and modules involved are not necessarily required by this application.

Through the description of the above embodiments, those skilled in the art can clearly understand that the method according to the above embodiments can be implemented by means of software plus a necessary general-purpose hardware platform, and of course also by hardware, but in many cases the former is Better implementation. Based on such an understanding, the technical solution of the present application can be embodied in the form of a software product in essence or in other words, the part that contributes to the prior art, and the computer software product is stored in a storage medium (such as ROM (Read-Only Memory, Read-only memory)/RAM (Random Access Memory, random access memory), magnetic disk, optical disk), including several instructions to make a terminal device (which can be a mobile phone, computer, server, or network device, etc.) execute this Applies the method of each embodiment.

According to another aspect of the embodiments of the present application, there is also provided an apparatus for recording retry in business processing for implementing the above method for recording retry in business processing. Fig. 4 is a structural block diagram of an optional device for recording retry in business processing according to an embodiment of the present application. As shown in Fig. 4, the device may include:

The first acquisition module 401 is configured to acquire an associated record related to the target task to be executed, wherein the associated record includes the current number of retries of the method function corresponding to the target task, the current time, and the time between the current time and the next execution time the interval of time;

A storage module 402, configured to store the associated records in the first preset table, and run the target task;

The transfer module 403 is used to move the associated record to the second preset table or the third preset table according to the running result and the target number of times obtained after the target thread scans the associated record, wherein the target number of times is based on the interval time length pair method function The preset number of times has been invoked, and the value obtained by adding the preset number of times to the current number of retries.

It should be noted that the first acquisition module 401 in this embodiment can be used to perform the above step S101, the storage module 402 in this embodiment can be used to perform the above step S102, and the transfer module 403 in this embodiment can be used for Execute the above step S103.

Through the above modules, the first preset table, the second preset table and the third preset table are set in advance, and all related records are first saved in the first preset table for trace preservation, and then according to the target task to be executed The call operation results of the related associated records and the number of retries of the associated records are transferred to the second preset table or the third preset table, so that the retries are preserved regardless of success or failure, so that timely query can be realized The purpose of retrying records, accurately locating problems, and improving work efficiency, and then solving the problem of retrying without leaving traces in related technologies, and subsequent inability to query retrying records in time.

As an optional embodiment, the transfer module includes:

The first transfer unit is used to move the associated record to the second preset table when the operation result is successful;

The adjustment unit is configured to use the target thread to scan the first preset table one after another when the operation result is a failure, obtain target records satisfying the preset conditions, perform calls on the target records, and adjust the current retry times of the target records value;

The second transfer unit is configured to move the target record to a third preset table when it is determined that the value of the current number of retries of the adjusted target record is greater than the first preset threshold, wherein the associated record contains the target record .

As an optional embodiment, the adjustment unit includes:

The first obtaining submodule is used to obtain the target record whose next execution time is less than or equal to the current time of the target thread in the associated record;

A sub-module is added for calling the target record, and increasing the current number of retries of the target record by a first preset value to obtain an intermediate number of retries after the first preset value is increased.

As an optional embodiment, the second transfer unit includes:

The second acquisition sub-module is used to acquire the current time of the number of intermediate retries;

The calculation sub-module is used to calculate the next execution time of the target record corresponding to the intermediate retry times according to the current time and the interval length of the intermediate retry times;

The transfer sub-module is used to call the target record corresponding to the intermediate retry count when the current time reaches the next execution time of the target record corresponding to the intermediate retry count until the sum of multiple preset values is the target count, and When the target count is greater than the first preset threshold, the target record is moved to the third preset table.

As an optional embodiment, the device also includes:

The third transfer unit is configured to transfer the repaired error object in the third preset table under the condition that the error object in the third preset table is successfully repaired after the associated record is moved to the third preset table. where the reference record is moved to the second default table;

The first setting module is used to set the current number of retries of the reference record as the initial numerical state, and set the next execution time of the reference record as the current time;

The trigger module is used for calling the reference record and triggering the retry mechanism when the actual time reaches the current time.

As an optional embodiment, the device also includes:

The second setting module is used to set the priority of multiple method functions corresponding to the target task;

A traversal module, configured to traverse the associated records in the currently acquired first preset table;

The execution module is used to put the associated record where the first method function is located at the end of the second preset table when it is determined that the priority of the first method function is greater than the second preset threshold, and execute the first method function The priority of the function is reduced by a second preset value; when it is determined that the priority of the function of the second method is equal to the second preset threshold, the function of the second method is called.

As an optional embodiment, the device also includes:

A scanning module, configured to use the target thread to successively scan the first preset table after traversing the associated records in the currently acquired first preset table;

An adding module, configured to continue adding associated records for which priority comparison operations have not been performed when it is determined that the number of associated records in the first preset table for which priority comparison operations have been performed exceeds a third preset threshold.

According to still another aspect of the embodiments of the present application, there is also provided an electronic device for implementing the above method for recording retry in business processing, and the electronic device may be a server, a terminal, or a combination thereof.

Fig. 5 is a structural block diagram of an optional electronic device according to the embodiment of the present application, as shown in Fig. 502 and memory 503 complete mutual communication through communication bus 504, wherein,

memory 503, for storing computer programs;

When the processor 501 is used to execute the computer program stored on the memory 503, the following steps are implemented:

Obtain an associated record related to the target task to be executed, wherein the associated record includes the current number of retries, the current time, and the interval between the current time and the next execution time of the method function corresponding to the target task;

storing the associated records in the first preset table, and running the target task;

According to the running result and the target number of times obtained after the target thread scans the associated record, move the associated record to the second preset table or the third preset table, wherein the target number of times is the preset number of times the method function is called based on the interval length, And the value obtained by adding the preset number of times to the current number of retries.

Optionally, in this embodiment, the aforementioned communication bus may be a PCI (Peripheral Component Interconnect, Peripheral Component Interconnect Standard) bus, or an EISA (Extended Industry Standard Architecture, Extended Industry Standard Architecture) bus, etc. The communication bus can be divided into an address bus, a data bus, a control bus, and the like. For ease of representation, only one thick line is used in FIG. 5 , but it does not mean that there is only one bus or one type of bus.

The communication interface is used for communication between the electronic device and other devices.

The memory may include RAM, and may also include non-volatile memory (non-volatile memory), for example, at least one disk memory. Optionally, the memory may also be at least one storage device located away from the aforementioned processor.

As an example, as shown in FIG. 5 , the memory 503 may include, but is not limited to, the first acquisition module 401 , the storage module 402 , and the transfer module 403 in the apparatus for recording retry in business processing. In addition, it may also include but not limited to other module units in the above-mentioned apparatus for recording retries in business processing, which will not be described in detail in this example.

Above-mentioned processor can be general-purpose processor, can include but not limited to: CPU (Central Processing Unit, central processing unit), NP (Network Processor, network processor) etc.; Can also be DSP (DigitalSignal Processing, digital signal processor), ASIC (Application Specific Integrated Circuit, application specific integrated circuit), FPGA (Field-Programmable Gate Array, field programmable gate array) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components.

In addition, the above-mentioned electronic device further includes: a display, used for displaying the result of retrying records in business processing.

Optionally, for specific examples in this embodiment, reference may be made to the examples described in the foregoing embodiments, and details are not repeated in this embodiment.

Those of ordinary skill in the art can understand that the structure shown in Figure 5 is only for illustration, and the device that implements the method for recording retry in the above-mentioned business processing can be a terminal device, and the terminal device can be a smart phone (such as an Android phone, an iOS phone, etc. ), Tablet PCs, PDAs, and mobile Internet devices (Mobile Internet Devices, MID), PAD and other terminal equipment. FIG. 5 does not limit the structure of the above-mentioned electronic equipment. For example, the terminal device may also include more or less components than those shown in FIG. 5 (such as a network interface, a display device, etc.), or have a different configuration from that shown in FIG. 5 .

Those skilled in the art can understand that all or part of the steps in the various methods of the above embodiments can be completed by instructing hardware related to the terminal device through a program, and the program can be stored in a computer-readable storage medium, and the storage medium can be Including: flash disk, ROM, RAM, magnetic disk or optical disk, etc.

According to still another aspect of the embodiments of the present application, a storage medium is also provided. Optionally, in this embodiment, the above-mentioned storage medium may be used to execute the program code of the method for recording retry in business processing.

Optionally, in this embodiment, the foregoing storage medium may be located on at least one network device among the plurality of network devices in the network shown in the foregoing embodiments.

Optionally, in this embodiment, the storage medium is configured to store program codes for performing the following steps:

Obtain an associated record related to the target task to be executed, wherein the associated record includes the current number of retries, the current time, and the interval between the current time and the next execution time of the method function corresponding to the target task;

storing the associated records in the first preset table, and running the target task;

According to the running result and the target number of times obtained after the target thread scans the associated record, move the associated record to the second preset table or the third preset table, wherein the target number of times is the preset number of times the method function is called based on the interval length, And the value obtained by adding the preset number of times to the current number of retries.

Optionally, for specific examples in this embodiment, reference may be made to the examples described in the foregoing embodiments, which will not be repeated in this embodiment.

Optionally, in this embodiment, the above-mentioned storage medium may include, but not limited to, various media capable of storing program codes such as USB flash drive, ROM, RAM, removable hard disk, magnetic disk, or optical disk.

According to yet another aspect of the embodiments of the present application, a computer program product or computer program is also provided, the computer program product or computer program includes computer instructions, and the computer instructions are stored in a computer-readable storage medium; the processor of the computer device The computer instruction is read from the computer-readable storage medium, and the processor executes the computer instruction, so that the computer device executes the method steps of recording retry in business processing in any one of the above embodiments.

The serial numbers of the above embodiments of the present application are for description only, and do not represent the advantages and disadvantages of the embodiments.

If the integrated units in the above embodiments are realized in the form of software function units and sold or used as independent products, they can be stored in the above computer-readable storage medium. Based on this understanding, the technical solution of the present application is essentially or part of the contribution to the prior art, or all or part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage medium. Several instructions are included to enable one or more computer devices (which may be personal computers, servers or network devices, etc.) to execute all or part of the steps of the method for recording retry in business processing in various embodiments of the present application.

In the above-mentioned embodiments of the present application, the descriptions of each embodiment have their own emphases, and for parts not described in detail in a certain embodiment, reference may be made to relevant descriptions of other embodiments.

In the several embodiments provided in this application, it should be understood that the disclosed client can be implemented in other ways. Wherein, the device embodiments described above are only illustrative, such as the division of units, which is only a logical function division, and there may be other division methods in actual implementation, for example, multiple units or components can be combined or integrated into Another system, or some features may be ignored, or not implemented. In another point, the mutual coupling or direct coupling or communication connection shown or discussed may be through some interfaces, and the indirect coupling or communication connection of units or modules may be in electrical or other forms.

A unit described as a separate component may or may not be physically separated, and a component displayed as a unit may or may not be a physical unit, that is, it may be located in one place, or may be distributed to multiple network units. Part or all of the units can be selected according to actual needs to achieve the purpose of the solution provided in this embodiment.

In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, each unit may exist separately physically, or two or more units may be integrated into one unit. The above-mentioned integrated units can be implemented in the form of hardware or in the form of software functional units.

The above description is only the preferred embodiment of the present application. It should be pointed out that for those of ordinary skill in the art, without departing from the principle of the present application, some improvements and modifications can also be made. These improvements and modifications are also It should be regarded as the protection scope of this application.

Claims (10)

1. A method for logging retries in a transaction, the method comprising:

acquiring an association record related to a target task to be executed, wherein the association record comprises the current retry times and the current time of a method function corresponding to the target task and the interval duration between the current time and the next execution time;

storing the association record to a first preset table, and operating the target task;

and moving the association record to a second preset table or a third preset table according to the operation result and the target frequency acquired after the association record is scanned by the target thread, wherein the target frequency is a value obtained after the preset frequency is added to the current retry frequency by calling the method function based on the interval duration.

2. The method of claim 1, wherein moving the association record to a second preset table or a third preset table according to the running result and the target times obtained after the target thread scans the association record comprises:

under the condition that the operation result is successful, the association record is moved to the second preset table;

under the condition that the operation result is failure, the target thread is utilized to successively scan the first preset table, a target record meeting preset conditions is obtained, the target record is called, and the value of the current retry number of the target record is adjusted;

and under the condition that the adjusted numerical value of the current retry times of the target record is larger than a first preset threshold value, moving the target record to the third preset table, wherein the associated record comprises the target record.

3. The method of claim 2, wherein the obtaining a target record satisfying a predetermined condition, performing a call to the target record, and adjusting the value of the current retry number of the target record comprises:

acquiring the target record of which the next execution time is less than or equal to the current time of the target thread in the associated records;

and executing calling on the target record, and increasing the current retry number of the target record by a first preset value to obtain the intermediate retry number after the first preset value is increased.

4. The method of claim 3, wherein the moving the target record to the third predetermined table in the case that it is determined that the value of the adjusted current retry number of the target record is greater than the first predetermined threshold value comprises:

obtaining the current time of the intermediate retry times;

calculating the next execution time of the target record corresponding to the intermediate retry times according to the current time of the intermediate retry times and the interval duration;

and when the current time reaches the next execution time of the target record corresponding to the intermediate retry times, executing calling on the target record corresponding to the intermediate retry times until the sum of the preset values is the target times and the target times are greater than the first preset threshold value, and moving the target record to the third preset table.

5. The method of claim 1, wherein after moving the association record to a third predetermined table, the method further comprises:

under the condition that the error objects in the third preset table are successfully repaired, moving the reference record where the repaired error objects in the third preset table are located to the second preset table;

setting the current retry times of the reference records as an initial numerical value state, and setting the next execution time of the reference records as the current time;

and under the condition that the actual time reaches the current time, calling the reference record to trigger a retry mechanism.

6. The method of any of claims 1 to 5, further comprising:

setting the priorities of a plurality of method functions corresponding to the target task;

traversing the currently acquired association record in the first preset table;

under the condition that the priority of a first method function is determined to be larger than a second preset threshold value, recording the association of the first method function to the tail of the second preset table, and performing operation of reducing a second preset numerical value on the priority of the first method function; in the event that it is determined that there is a second method function whose priority is equal to the second preset threshold, performing a call to the second method function.

7. The method of claim 6, wherein after said traversing said currently obtained associated record in said first predetermined table, said method further comprises:

scanning the first preset table by using the target thread in sequence;

in the case that the number of the executed priority comparison operations of the associated records in the first preset table is determined to exceed a third preset threshold, continuing to increase the associated records which are not executed with priority comparison operations.

8. An apparatus for recording retries in a transaction, the apparatus comprising:

the system comprises a first acquisition module, a second acquisition module and a third acquisition module, wherein the first acquisition module is used for acquiring an association record related to a target task to be executed, and the association record comprises the current retry times and the current time of a method function corresponding to the target task and the interval duration between the current time and the next execution time;

the storage module is used for storing the association record to a first preset table and operating the target task;

and the transfer module is used for transferring the association record to a second preset table or a third preset table according to the operation result and the target times acquired after the association record is scanned by the target thread, wherein the target times are values obtained by calling the preset times for the method function based on the interval duration and increasing the preset times for the current retry times.

9. An electronic device comprising a processor, a communication interface, a memory and a communication bus, wherein said processor, said communication interface and said memory communicate with each other via said communication bus,

the memory for storing a computer program;

the processor for performing the method steps of any one of claims 1 to 7 by running the computer program stored on the memory.

10. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the method steps of any one of claims 1 to 7.

Images