CN112379986B

CN112379986B - Task processing method and device and electronic equipment

Info

Publication number: CN112379986B
Application number: CN202011282526.5A
Authority: CN
Inventors: 郑海波
Original assignee: Beijing Zitiao Network Technology Co Ltd
Current assignee: Beijing Zitiao Network Technology Co Ltd
Priority date: 2020-11-16
Filing date: 2020-11-16
Publication date: 2023-12-12
Anticipated expiration: 2040-11-16
Also published as: CN112379986A

Abstract

The embodiment of the invention discloses a task processing method, a task processing device and electronic equipment. One embodiment of the method comprises the following steps: acquiring preset starting time and starting time tolerance of a task to be executed, wherein the starting time tolerance is used for indicating an acceptable difference between the actual starting time and the preset starting time; and determining the actual starting time of the task to be executed based on the preset starting time and the starting time tolerance. Thus, a new task processing mode is provided.

Description

Task processing method and device and electronic equipment

Technical Field

The disclosure relates to the field of computer technology, and in particular, to a task processing method, a task processing device and electronic equipment.

Background

With the rapid development and progress of services and technologies, distributed technologies are increasingly popular in system architecture. Timed tasks may also be upgraded in a distributed system architecture to distributed task scheduling. In the internet information system, distributed task scheduling is increasingly widely used to cope with the timing task scene under the huge user volume data volume of the internet.

Generally, a timed task is understood as having a system automatically perform a predefined task according to a set time rule to automatically process certain business logic.

Disclosure of Invention

This disclosure is provided in part to introduce concepts in a simplified form that are further described below in the detailed description. This disclosure is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.

In a first aspect, an embodiment of the present disclosure provides a task processing method, including: acquiring preset starting time and starting time tolerance of a task to be executed, wherein the starting time tolerance is used for indicating an acceptable difference between the actual starting time and the preset starting time; and determining the actual starting time of the task to be executed based on the preset starting time and the starting time tolerance.

In a second aspect, an embodiment of the present disclosure provides a task processing device, including: the system comprises an acquisition unit, a control unit and a control unit, wherein the acquisition unit is used for acquiring preset starting time and starting time tolerance of a task to be executed, and the starting time tolerance is used for indicating an acceptable difference between the actual starting time and the preset starting time; and the determining unit is used for determining the actual starting time of the task to be executed based on the preset starting time and the starting time tolerance.

In a third aspect, an embodiment of the present disclosure provides an electronic device, including: one or more processors; storage means for storing one or more programs which, when executed by the one or more processors, cause the one or more processors to implement the method as described in the first aspect.

In a fourth aspect, embodiments of the present disclosure provide a computer readable medium having stored thereon a computer program which, when executed by a processor, implements the first aspect.

It should be noted that, according to the task processing method provided by the embodiment, the actual starting time of the task to be executed is determined based on the preset starting time and the starting time tolerance, so that the starting time of the task can be corrected, some tasks can be executed in advance, or some tasks can be executed after being executed, so that the starting time of a plurality of tasks is spread out within a period of time as much as possible, the starting speed of the tasks is controlled, the task execution is more balanced, the occurrence of concentrated and sudden increase of the task is reduced, and the possibility of breakdown due to overlarge pressure of an executor is reduced.

Drawings

The above and other features, advantages, and aspects of embodiments of the present disclosure will become more apparent by reference to the following detailed description when taken in conjunction with the accompanying drawings. The same or similar reference numbers will be used throughout the drawings to refer to the same or like elements. It should be understood that the figures are schematic and that elements and components are not necessarily drawn to scale.

FIG. 1 is a flow chart of one embodiment of a task processing method according to the present disclosure;

FIG. 2 is a flow chart of another embodiment of a task processing method according to the present disclosure;

FIG. 3 is a flow chart of yet another embodiment of a task processing method according to the present disclosure;

FIG. 4 is a flow chart of yet another embodiment of a task processing method according to the present disclosure;

FIG. 5 is a flow chart of one embodiment of a task processing device according to the present disclosure;

FIG. 6 is an exemplary system architecture in which a task processing method of one embodiment of the present disclosure may be applied;

fig. 7 is a schematic view of a basic structure of an electronic device provided according to an embodiment of the present disclosure.

Detailed Description

Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While certain embodiments of the present disclosure have been shown in the accompanying drawings, it is to be understood that the present disclosure may be embodied in various forms and should not be construed as limited to the embodiments set forth herein, but are provided to provide a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are for illustration purposes only and are not intended to limit the scope of the present disclosure.

It should be understood that the various steps recited in the method embodiments of the present disclosure may be performed in a different order and/or performed in parallel. Furthermore, method embodiments may include additional steps and/or omit performing the illustrated steps. The scope of the present disclosure is not limited in this respect.

The term "including" and variations thereof as used herein are intended to be open-ended, i.e., including, but not limited to. The term "based on" is based at least in part on. The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments. Related definitions of other terms will be given in the description below.

It should be noted that the terms "first," "second," and the like in this disclosure are merely used to distinguish between different devices, modules, or units and are not used to define an order or interdependence of functions performed by the devices, modules, or units.

It should be noted that references to "one", "a plurality" and "a plurality" in this disclosure are intended to be illustrative rather than limiting, and those of ordinary skill in the art will appreciate that "one or more" is intended to be understood as "one or more" unless the context clearly indicates otherwise.

The names of messages or information interacted between the various devices in the embodiments of the present disclosure are for illustrative purposes only and are not intended to limit the scope of such messages or information.

Referring to FIG. 1, a flow of one embodiment of a task processing method according to the present disclosure is shown. The task processing method is applied to the server. The task processing method as shown in fig. 1 comprises the following steps:

step 101, obtaining preset starting time and starting time tolerance of a task to be executed.

In this embodiment, the execution body (e.g., server) of the task processing method may acquire a preset start time and a start time tolerance of a task to be executed.

Here, the preset start time may be a time preset for a task to be executed to start the task. Typically, a task may be initiated first and then assigned to an executor for execution.

Here, the start-up time tolerance is used to indicate an acceptable difference between the actual start-up time and the preset start-up time.

Here, the specific value of the start time tolerance may be set according to the actual application scenario, which is not limited herein.

Here, there is a correspondence between the preset start-up time and the start-up time tolerance.

Alternatively, the preset start time and the start time tolerance may be in a one-to-one relationship. As an example, each task to be executed has its own preset start time and its own start time tolerance, so that the preset start time and the start time tolerance of the task to be executed are in one-to-one correspondence.

Alternatively, the preset starting time and the starting time tolerance may be a many-to-one correspondence. As an example, a start time tolerance may be uniformly set for a plurality of preset start times; therefore, the corresponding relation between the preset starting time and the starting time tolerance is many-to-one.

In some application scenarios, there may be an aggregated distribution of timing tasks over a time period. In this time range, the number of timing tasks to be started is large, and even there may be a case that a plurality of timing tasks need to be started at the same time (for example, 10 timing tasks are defined to be started in early morning), and in this time, particularly at these special time points, the execution pressure of each actuator is very high. This time range is the time period of dense execution of the timing tasks of the business system, and these special time points (for example, early morning points in the previous example) are the dense execution points of the timing tasks in the system. In some scenarios, the timing service may not need to start execution at exactly the specified time point, which is also difficult to achieve in practice; because tasks require some time to execute, the time difference between the queue head and tail of the batch processing tasks is relatively large, so that the execution time of the timing tasks is not required to be strict, and tolerance exists for deviation of starting time, namely starting time tolerance. By querying the system for a defined preset start time, and querying for a timed task start time tolerance (e.g., 10 minutes, a specific value may be defined on the system).

In some application scenarios, the execution body may also be referred to as a scheduler, i.e. for scheduling tasks to be executed.

In some application scenarios, in distributed task scheduling, the scheduler may initiate tasks to be performed at predetermined times; specifically, the scheduler may parse a fixed time interval rule to start tasks at regular time. In the distributed task scheduling technical scenario, there is a process of scheduling and distributing tasks from the time the tasks are started to the time they are executed by the executor due to the distributed service characteristics.

In some application scenarios, task scheduling may include parsing timed time rules. Because of the requirement of system service, most of timing tasks are periodic tasks, for example, the tasks to be executed are started according to periodic rules such as days, weeks, fixed time intervals and the like, the tasks are required to be distributed to a certain task executor in the distributed service for execution after being started, or the tasks are respectively transmitted to a plurality of task executors after being sliced. It can be seen that the task scheduling process is a logical key point of the whole timing service, and is used for parsing the time rule, starting the task and distributing the task to the executor.

Step 102, determining the actual starting time of the task to be executed based on the preset starting time and the starting time tolerance.

In this embodiment, the execution body may determine the actual start time of the task to be executed according to the preset start time and the start time tolerance.

Here, the above-described actual start-up time may indicate a time at which the task to be executed is actually started up.

In some embodiments, the number of tasks to be performed is at least two. The step 102 may include: based on the distribution of at least two preset starting times in a first preset time period, the preset starting time of the task to be executed is adjusted within the starting time tolerance of the preset starting time.

Here, the preset start time in the first period may refer to a task to be executed in the first period.

As an example, at the time of zero point, a future 24 hours may be taken as the first period. And determining the task to be executed with the preset starting time in the future 24 hours as the task to be executed in the first time period.

Here, the distribution of at least two preset start-up times may be a distribution of at least the preset start-up times within the first period of time.

Here, the distribution of the tasks to be performed in the first period may be determined by taking the time of the first period as the horizontal axis and the preset starting time of the tasks to be performed as the horizontal axis.

As an example, the first preset time period may be divided into a plurality of sub-time periods, and then the number of preset start-up times within each sub-time period is determined. Then, the number of preset starting times of each sub-time period content is averaged within the starting time tolerance range.

As an example, the time point at which the preset start-up times are aggregated may be determined first, and then, the preset start-up times near the time point at which the preset start-up times are aggregated (which is the vicinity may be set according to the actual application scenario) may be dispersed, for example, the preset start-up time with the maximum start-up time tolerance may be adjusted to the maximum extent.

It should be noted that, by adjusting the preset starting time according to the distribution of the preset starting time, the tasks to be executed are started in advance or later, the tasks to be executed which are concentrated in the prior art are scattered in a certain time period range, the tasks to be executed which are concentrated in the time are changed into staggered time for execution, some tasks to be executed are started in advance for several minutes, some tasks to be executed are started after the other minutes, and by controlling the starting speed of the new tasks to be executed, the tasks to be executed in the system are executed in a scattered manner, the parallel execution of the tasks to be executed by multiple tasks to be executed is changed into serial execution, and the execution pressure of the tasks to be executed of the system is dispersed.

In other words, within the tolerance range of the preset starting time, the starting time of the tasks is corrected in the time period of intensive starting of the tasks, some tasks are executed in advance appropriately, some tasks are executed after the execution, the starting time of a plurality of tasks is spread out as much as possible within a period of time, the starting speed of the tasks is controlled, and the execution of the tasks is more balanced.

In some embodiments, the step 102 may include: and adjusting the preset starting time of the task to be executed within the starting time tolerance of the preset starting time according to the preset starting time and the execution pressure of the at least one executor.

Here, the execution body may adjust the preset start time of the task to be executed within the start time tolerance according to the preset start time and the execution pressure of the at least one actuator.

Here, at least one executor is used for executing the task to be executed.

Here, the execution pressure of the at least one actuator may refer to a sum of the execution pressures of the at least one actuator. This execution pressure synthesis may be based on an addition or weighted sum of the execution pressures of the individual actuators.

As an example, the execution pressure of at least one of the actuators may be characterized by the number of outstanding tasks of the actuator.

It should be noted that, according to the total execution pressure of the executor, the preset starting time of the task to be executed is adjusted, so that parallel execution of the task can be reduced as much as possible, and the task can be executed in series as much as possible.

In some embodiments, the above method further comprises: and starting the task to be executed at the actual starting time.

Here, the actual start-up time is obtained by adjusting the preset start-up time.

It should be noted that, the execution body may start the task to be executed at the actual start time, so that the task may be started within the start time tolerance range, and may be further distributed to the executor in time for execution.

In some embodiments, the above method further comprises: determining task allocation priorities of the actuators based on execution pressures of each of the at least two actuators; and distributing the started tasks to be executed to the executors in the at least two executors based on the task distribution priorities.

The execution pressure of the actuator can be determined from the incomplete tasks of the actuator.

Alternatively, the execution pressure may be determined based on various parameters of the incomplete tasks of the actuator.

As an example, the above-described execution pressure may be determined according to the number of incomplete tasks.

As an example, the execution pressure may be determined based on the amount of unexecuted tasks of the incomplete tasks.

In some application scenarios, a task execution situation active reporting function is started on the distributed executor and sent to the scheduler. The number of the actuators can be elastically expanded along with the distributed system, the number of the actuators is not fixed but dynamic, a data reporting function module is realized on each actuator, and the newly deployed actuators also have the data reporting function. Only one data collection interface service needs to be realized on the scheduler, and each executor calls the interface to actively report the task execution condition data to the scheduler by adopting a fixed time interval (for example, 1 minute).

Here, the actuators allocated to the at least two actuators may include all of the actuators allocated to the at least two actuators, or may include some of the actuators allocated to the at least two actuators.

As an example, an a-executor performed 20 tasks in 1 minute, 3 tasks did not complete at the end of the 1 minute timer, B-executor performed 10 tasks in the same 1 minute, and 5 tasks did not complete at the end of the 1 minute timer, although the a-executor performed a large number of tasks, since 5 tasks remained on the B-executor for the next 1 minute period to continue execution, the B-executor was evaluated logically to have a next execution pressure greater than that of the a-executor. Comparing the same time frame of 1 minute, the more tasks are not performed on the actuator, the greater the execution pressure the actuator will be subjected to from the time frame of the next minute.

In some application scenarios, the scheduler dynamically adjusts the task allocation policy according to the evaluation result of each actuator, and balances the running conditions among the actuators. The scheduler evaluates the execution pressure which each actuator will face in the next time period according to the task execution condition in the previous time period reported by each actuator, reduces the priority of receiving new tasks for the actuator with high pressure, and preferentially distributes tasks to the actuators with low pressure. An executor priority list is maintained in a speed regulating valve in the scheduler, the priority of each executor is evaluated according to the execution condition, the task distribution strategy of the scheduler is controlled by the speed regulating valve, the aim that the execution condition of each executor on the task can be balanced is achieved, the situation that a plurality of random executors execute the task slowly is avoided, and the whole service operation is smoother and controllable. From the viewpoint of the actuators, the speed of task allocation to the actuators is adjusted within a time period, and the adjustment is continuously performed, so that the task execution situation of each actuator in the whole distributed system is generally balanced.

The task scheduling method has the advantages that the task scheduling is more intelligent and fine, task execution among distributed executors can be more balanced through control of the scheduler, task backlog conditions can be effectively improved, the executors can smoothly execute tasks in the whole, the severe fluctuation condition of task quantity is reduced, the performance potential of the distributed task scheduling system can be fully exerted, peak clipping and valley filling of the execution condition of distributed task scheduling are achieved in the global view, and overall optimal performance is sought.

In other words, since some tasks are executed for a long time and some tasks are executed for a short time, there often occurs a phenomenon that some actuators are executing tasks, some actuators are empty, and the task execution is unbalanced. According to the execution pressure, the priority of the executors is adjusted, and the task load condition of each executor can be perceived, so that an optimized distribution strategy is adopted, the task distribution speed is balanced, and the load of each executor is at the same level, and the execution of each task is more balanced.

In contrast, in some application scenarios, when many tasks executed at the same time occur, the task executor instance can be elastically expanded, the distributed capacity is exerted, more server resources are called to equally divide the tasks, so that the number of tasks on each task executor is reduced, the situation that the number of tasks is large is dealt with, and the corresponding solution thinking is that the service instance is elastically expanded. In addition, the task itself is a batch processing logic, for example, a promotion information reminder is sent to members meeting the conditions in the system periodically, when each task is executed, according to the query condition, the number of members which need to be sent to the time is obtained, the number of members is dynamic, when each execution is performed, the number of members is probably different, the number of people is sometimes small, when the number of members which need to be sent is great, the execution time of the task is longer, in order to shorten the execution time of the task, the task can be sliced first and then the slices can be routed to different executors, for example, every 1000 user identifiers are cut into 1 slice, thus each slice executed only needs to process 1000 user identifiers, the sliced task is executed in parallel on a plurality of executors, the total time of task execution is shortened a lot, and for a large-scale task similar to the situation, the corresponding solution idea is executed in parallel after the task slicing. The distributed task scheduling technology basically adopts the idea of elastic capacity expansion and task slicing to seek a solution to solve the problem of the increase of the pressure of the timing service, the design point of the idea is from the viewpoint of the executors, the elastic capacity expansion is to increase the number of the executors, and the task slicing is to make the tasks be distributed on a plurality of executor examples and then executed in parallel.

The method for elastically expanding the task executor depends on server resources, a container virtualization technology is used, a plurality of service instances can be started in a short time, but the server resources are always limited, the method of relying on money burning can solve some problems, machine resources always have bottlenecks, and when the capacity is expanded to a certain order of magnitude, maintaining the distributed states of a large number of service instances is also a great challenge, so that the method for elastically expanding the capacity cannot be abused, the number of the service instances of the executor is generally set to be limited to a threshold value, and dynamic capacity expansion is carried out according to service pressure in the threshold value. This can be generalized to the number bottleneck problem of elastic expansion.

The method for parallel execution after slicing the task is to divide a task to be executed into a plurality of subtasks according to a preset allocation rule, and the subtasks are respectively transmitted to different task executors for execution, and a common slicing rule is to group a batch task according to the number of user identifications, for example, batch 10000 pieces of data are divided into 10 groups according to 1000 pieces, namely, the batch task is sliced into 10 pieces. However, not all tasks are suitable for slicing, a task capable of slicing generally needs to have a fixed slicing dimension, and for batch processing tasks, this dimension is a data identifier, and for non-batch processing type tasks, for example, tasks such as initializing a system, many services and data operations are packaged in 1 system initialization task, and there is a relation of sequential execution among the services, so that a dimension capable of slicing cannot be found in such tasks, and therefore slicing cannot be performed.

The method provided by the application can jump out of the expansion or slicing layer, and a mode for improving the efficiency and stability of the actuator is provided from a new angle.

In some embodiments, the execution pressure is determined based on the number of tasks that the actuator is activated and did not perform completion within a second preset period of time.

As an example, a preset time before the point of time of task allocation may be determined as the second period of time.

In some embodiments, the execution pressure is determined by: dividing the time interval between the two task assignments into at least one sub-time interval, and acquiring the number of tasks which are started and not executed in each sub-time interval; and determining the execution pressure of the executor according to the task number corresponding to the at least one sub-time interval.

As an example, a task is allocated once at zero point zero and a task is allocated once at zero point zero 5. Five minutes between zero and five zero can be equally divided into 5 sub-time intervals. For each sub-time interval, the tasks that started during that sub-time interval and did not execute during that sub-time interval are counted. In other words, for the first task, if starting between zero point and zero point zero 1 point, execution is completed between zero point zero 2 point and zero point zero 3 point; then, the A task can be counted in the sub-time interval from zero to zero 1 minute as a task that starts and does not execute in the sub-time interval. For the sub-time interval zero 1 to zero 2, the sub-time interval zero 1 to zero 2 cannot be counted because the task a is not started in the sub-time interval.

It should be noted that, the task execution pressure of the executor is estimated by using the number of tasks that have been executed but not executed by the executor within a time period range, that is, the task execution pressure of the executor is estimated by using the time period range without being estimated at a time point, so that the situation that the extreme case difference of instantaneous execution at some time points affects the estimation result too much can be avoided, and the accuracy can be improved by using the time period range for estimation.

In some embodiments, the allocating the started task to be executed to the executor of the at least two executors based on the task allocation priority includes: and determining an executor to which the started task to be executed is to be allocated according to the task allocation priority and the historical execution time of the started task to be executed.

In some application scenarios, when the scheduler starts a periodic timing task each time, the starting time of the task is recorded, a callback interface of the scheduler is called after the task is executed, the completion time of the task is reported, the difference value of the time is the execution time of the task, the scheduler stores the execution time of the task, and the execution time of the task is estimated by taking an average value. This average value will get closer to the actual execution time of the task as it continues to execute.

When a new task is allocated, the scheduler refers to the historical execution time of the task, and preferentially allocates the task with long time consumption to the executor with small execution pressure of the current task, so that scheduling is more careful, and the pressure of the executor is balanced.

In other words, the execution time of the periodic task is collected, and the execution time of the task can be accurately predicted based on the average value of the historical execution times. The task execution speed is monitored, and according to the predicted execution time, the scheduling strategy of the task is more refined through the speed regulating valve, so that the task execution is more balanced.

In some application scenarios, these technical improvements of the scheduler can be packaged in a module called a speed regulating valve, the technical improvements of the scheduler are built in the scheduler service, if the code logic of the scheduler itself is directly modified, the modification points are scattered, so that the technical modifications are packaged in the speed regulating valve functional module, when the scheduler service of the outer layer calls the speed regulating valve of the inner layer to acquire a better scheduling strategy, and the speed regulating valve can adapt to various scheduler logics under the condition of interfacing with the scheduler of the outer layer through the packaging.

Referring to FIG. 2, a flow of one embodiment of a task processing method according to the present disclosure is shown. The task processing method is applied to the server. The task processing method as shown in fig. 2 comprises the following steps:

step 201, obtaining preset starting time and starting time tolerance of a task to be executed.

Step 202, adjusting the preset starting time of the task to be executed within the starting time tolerance of the preset starting time based on the distribution of at least two preset starting times within the first preset time period.

Step 203, adjusting the preset starting time of the task to be executed within the starting time tolerance according to the preset starting time and the execution pressure of the at least one executor.

Here, the at least one executor is configured to execute the task to be executed.

It should be noted that, the implementation details and technical effects of the present embodiment may refer to the descriptions of the corresponding parts in the present application, and are not repeated herein.

Referring to FIG. 3, a flow of one embodiment of a task processing method according to the present disclosure is shown. The task processing method is applied to the server. The task processing method as shown in fig. 3 comprises the following steps:

step 301, obtaining a preset starting time and a starting time tolerance of a task to be executed.

Step 302, adjusting the preset starting time of the task to be executed within the starting time tolerance according to the preset starting time and the execution pressure of the at least one executor.

Step 303, determining task allocation priorities of the actuators based on execution pressures of each of the at least two actuators.

Here, the execution pressure is determined according to the non-execution completion task of the actuator.

And step 304, distributing the started tasks to be executed to the executors in the at least two executors based on the task distribution priorities.

Referring to FIG. 4, a flow of one embodiment of a task processing method according to the present disclosure is shown. The task processing method is applied to the server. The task processing method as shown in fig. 4 includes the steps of:

Step 401, obtaining preset starting time and starting time tolerance of a task to be executed.

Step 402, adjusting the preset starting time of the task to be executed within the starting time tolerance of the preset starting time based on the distribution of at least two preset starting times within the first preset time period.

Step 403, adjusting the preset starting time of the task to be executed within the starting time tolerance according to the preset starting time and the execution pressure of the at least one executor.

Step 404, determining the actual starting time of the task to be executed, and starting the task to be executed at the actual activating time.

Here, the actual start time of the task to be performed may be determined according to the adjustment in step 402 and/or step 403.

Step 405, determining task allocation priorities of the actuators based on execution pressures of each of the at least two actuators.

And step 406, distributing the started tasks to be executed to the executors in the at least two executors based on the task distribution priorities.

With further reference to fig. 5, as an implementation of the method shown in the foregoing figures, the present disclosure provides an embodiment of a task processing device, where the embodiment of the device corresponds to the embodiment of the method shown in fig. 1, and the device may be specifically applied to various electronic devices.

As shown in fig. 5, the task processing device of the present embodiment includes: an acquisition unit 501 and a determination unit 502; the acquiring unit 501 is configured to acquire a preset start time and a start time tolerance of a task to be executed, where the start time tolerance is used to indicate an acceptable difference between an actual start time and the preset start time; a determining unit 502, configured to determine an actual start time of the task to be executed based on the preset start time and the start time tolerance.

In this embodiment, the specific processing of the determining unit, the first establishing unit 501, the second establishing unit 502, and the technical effects thereof in the task processing device may refer to the description of step 101 and step 102 in the corresponding embodiment of fig. 1, and are not described herein.

In some embodiments, the number of tasks to be performed is at least two; and said step 102 comprises: based on the distribution of at least two preset starting times in a first preset time period, the preset starting time of the task to be executed is adjusted within the starting time tolerance of the preset starting time.

In some embodiments, the step of determining the actual start time of the task to be performed based on the preset start time and the start time tolerance includes: and adjusting the preset starting time of the task to be executed within the starting time tolerance according to the preset starting time and the execution pressure of the at least one executor, wherein the at least one executor is used for executing the task to be executed.

In some embodiments, the apparatus is further to: and starting the task to be executed at the actual starting time.

In some embodiments, the apparatus is further to: determining task allocation priorities of the actuators based on execution pressures of each of the at least two actuators, wherein the execution pressures are determined according to unexecuted tasks of the actuators; and distributing the started tasks to be executed to the executors in the at least two executors based on the task distribution priorities.

Referring to fig. 6, fig. 6 illustrates an exemplary system architecture in which a task processing method of an embodiment of the present disclosure may be applied.

As shown in fig. 6, the system architecture may include executors 601, 602, 603, a network 604, and a scheduler 605. The network 604 is used as a medium to provide communication links between the executors 601, 602, 603 and the scheduler 605. The network 604 may include various connection types, such as wired, wireless communication links, or fiber optic cables, among others.

The executors 601, 602, 603 may interact with the scheduler 605 through the network 604 to receive or send messages, etc.

The actuators 601, 602, 603 may be hardware or software. When the executors 601, 602, 603 are hardware, various electronic devices having a calculation function may be used, for example, the task to be executed allocated by the scheduler 605 is received to be executed, and the execution result is fed back. When the actuators 601, 602, 603 are software, they can be installed in the above-listed electronic devices. Which may be implemented as multiple software or software modules (e.g., software or software modules for providing distributed services) or as a single software or software module. The present invention is not particularly limited herein.

The scheduler 605 may be a server providing various services, for example, receiving task execution information transmitted from the executors 601, 602, 603, or adjusting a preset start time of a task, or pulling up a task at an actual start time, or transmitting a task to be executed to the executors 601, 602, 603.

It should be noted that, the task processing method provided by the embodiment of the present disclosure may be executed by the scheduler 605, and accordingly, the task processing device may be disposed in the scheduler 605.

It should be understood that the number of executors, networks, and schedulers in fig. 6 are merely illustrative. There may be any number of actuators, networks, and schedulers, as desired for an implementation.

Referring now to fig. 7, a schematic diagram of an electronic device (e.g., the server of fig. 6) suitable for use in implementing embodiments of the present disclosure is shown. The terminal devices in the embodiments of the present disclosure may include, but are not limited to, mobile terminals such as mobile phones, notebook computers, digital broadcast receivers, PDAs (personal digital assistants), PADs (tablet computers), PMPs (portable multimedia players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and the like, and stationary terminals such as digital TVs, desktop computers, and the like. The electronic device shown in fig. 7 is merely an example and should not be construed to limit the functionality and scope of use of the disclosed embodiments.

As shown in fig. 7, the electronic device may include a processing means (e.g., a central processing unit, a graphics processor, etc.) 701, which may perform various appropriate actions and processes according to a program stored in a Read Only Memory (ROM) 702 or a program loaded from a storage means 708 into a Random Access Memory (RAM) 703. In the RAM 703, various programs and data required for the operation of the electronic device 700 are also stored. The processing device 701, the ROM 702, and the RAM 703 are connected to each other through a bus 704. An input/output (I/O) interface 705 is also connected to bus 704.

In general, the following devices may be connected to the I/O interface 705: input devices 706 including, for example, a touch screen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, and the like; an output device 707 including, for example, a Liquid Crystal Display (LCD), a speaker, a vibrator, and the like; storage 708 including, for example, magnetic tape, hard disk, etc.; and a communication device 709. The communication means 709 may allow the electronic device to communicate with other devices wirelessly or by wire to exchange data. While fig. 7 shows an electronic device having various means, it is to be understood that not all of the illustrated means are required to be implemented or provided. More or fewer devices may be implemented or provided instead.

In particular, according to embodiments of the present disclosure, the processes described above with reference to flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a non-transitory computer readable medium, the computer program comprising program code for performing the method shown in the flow chart. In such an embodiment, the computer program may be downloaded and installed from a network via communication device 709, or installed from storage 708, or installed from ROM 702. The above-described functions defined in the methods of the embodiments of the present disclosure are performed when the computer program is executed by the processing device 701.

It should be noted that the computer readable medium described in the present disclosure may be a computer readable signal medium or a computer readable storage medium, or any combination of the two. The computer readable storage medium can be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples of the computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this disclosure, a computer-readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present disclosure, however, the computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, with the computer-readable program code embodied therein. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination of the foregoing. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: electrical wires, fiber optic cables, RF (radio frequency), and the like, or any suitable combination of the foregoing.

In some implementations, the clients, servers may communicate using any currently known or future developed network protocol, such as HTTP (HyperText Transfer Protocol ), and may be interconnected with any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include a local area network ("LAN"), a wide area network ("WAN"), the internet (e.g., the internet), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future developed networks.

The computer readable medium may be contained in the electronic device; or may exist alone without being incorporated into the electronic device.

The computer readable medium carries one or more programs which, when executed by the electronic device, cause the electronic device to: acquiring preset starting time and starting time tolerance of a task to be executed, wherein the starting time tolerance is used for indicating an acceptable difference between the actual starting time and the preset starting time; and determining the actual starting time of the task to be executed based on the preset starting time and the starting time tolerance.

Computer program code for carrying out operations of the present disclosure may be written in one or more programming languages, including, but not limited to, an object oriented programming language such as Java, smalltalk, C ++ and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected to an external computer (for example, through the Internet using an Internet service provider).

The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The units involved in the embodiments of the present disclosure may be implemented by means of software, or may be implemented by means of hardware. The name of the unit does not constitute a limitation of the unit itself in some cases, and for example, the acquisition unit may be described as "a unit that acquires a preset start time".

The functions described above herein may be performed, at least in part, by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: a Field Programmable Gate Array (FPGA), an Application Specific Integrated Circuit (ASIC), an Application Specific Standard Product (ASSP), a system on a chip (SOC), a Complex Programmable Logic Device (CPLD), and the like.

In the context of this disclosure, a machine-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. The machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

The foregoing description is only of the preferred embodiments of the present disclosure and description of the principles of the technology being employed. It will be appreciated by persons skilled in the art that the scope of the disclosure referred to in this disclosure is not limited to the specific combinations of features described above, but also covers other embodiments which may be formed by any combination of features described above or equivalents thereof without departing from the spirit of the disclosure. Such as those described above, are mutually substituted with the technical features having similar functions disclosed in the present disclosure (but not limited thereto).

Moreover, although operations are depicted in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order. In certain circumstances, multitasking and parallel processing may be advantageous. Likewise, while several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of the present disclosure. Certain features that are described in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination.

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are example forms of implementing the claims.

Claims

1. A method of task processing, comprising:

acquiring preset starting time and starting time tolerance of a task to be executed, wherein the starting time tolerance is used for indicating an acceptable difference between the actual starting time and the preset starting time;

determining the actual starting time of a task to be executed based on the preset starting time and the starting time tolerance;

determining task allocation priorities of the actuators based on execution pressures of each of the at least two actuators, wherein the execution pressures are determined according to unexecuted tasks of the actuators;

distributing the started tasks to be executed to the executors in the at least two executors based on the task distribution priorities;

wherein, the determination mode of the execution pressure comprises: dividing the time interval between the two task assignments into at least one sub-time interval, and acquiring the number of tasks which are started and not executed in the sub-time interval; and determining the execution pressure of the executor according to the task number corresponding to the at least one sub-time interval.

2. The method according to claim 1, wherein the number of tasks to be performed is at least two; and

the determining the actual starting time of the task to be executed based on the preset starting time and the starting time tolerance comprises the following steps:

based on the distribution of at least two preset starting times in a first preset time period, the preset starting time of the task to be executed is adjusted within the starting time tolerance of the preset starting time.

3. The method according to claim 1 or 2, wherein determining the actual start-up time of the task to be performed based on the preset start-up time and start-up time tolerance comprises:

and adjusting the preset starting time of the task to be executed within the starting time tolerance according to the preset starting time and the execution pressure of at least one executor, wherein the at least one executor is used for executing the task to be executed.

4. The method according to claim 1, wherein the method further comprises:

and starting the task to be executed at the actual starting time.

5. The method of claim 1, wherein the execution pressure is determined based on a number of tasks that the actuator is activated and has not performed to complete within a second predetermined period of time.

6. The method of claim 1, wherein assigning the initiated task to be performed to an actuator of the at least two actuators based on task assignment priorities comprises:

and determining an executor to which the started task to be executed is to be allocated according to the task allocation priority and the historical execution time of the started task to be executed.

7. A task processing device, comprising:

the system comprises an acquisition unit, a control unit and a control unit, wherein the acquisition unit is used for acquiring preset starting time and starting time tolerance of a task to be executed, and the starting time tolerance is used for indicating an acceptable difference between the actual starting time and the preset starting time;

a determining unit for determining the actual starting time of the task to be executed based on the preset starting time and the starting time tolerance

The device is also for: determining task allocation priorities of the actuators based on execution pressures of each of the at least two actuators, wherein the execution pressures are determined according to unexecuted tasks of the actuators; distributing the started tasks to be executed to the executors in the at least two executors based on the task distribution priorities;

8. An electronic device, comprising:

one or more processors;

storage means for storing one or more programs,

when executed by the one or more processors, causes the one or more processors to implement the method of any of claims 1-6.

9. A computer readable medium, on which a computer program is stored, characterized in that the program, when being executed by a processor, implements the method according to any of claims 1-6.