CN116302391A - Multithreading task processing method and related device - Google Patents

Abstract

The application discloses a multithreading task processing method, which comprises the following steps: storing the received tasks into a circulation queue corresponding to the thread, and dequeuing the tasks in the circulation queue according to the first-in-first-out sequence; and executing the tasks queued from the cyclic queue through the threads and the memory resources corresponding to the threads to obtain an execution result. The received tasks are stored in the circular queue, the circular queue sequentially dequeues the tasks, and finally, each dequeued task is executed by the corresponding thread and the memory resource corresponding to the thread, so that an execution result is obtained, the task is executed by the thread according to the sequence by adopting the corresponding memory resource, the situation that the task occupies the resource and the thread is avoided, the multithreading access is realized without using a lock mechanism, and the processing efficiency of the multithreading is improved. The application also discloses a multithreaded task processing device, a computing device and a computer readable storage medium, which have the beneficial effects.

Description

A multi-threaded task processing method and related device

technical field

The present application relates to the field of computer technology, and in particular to a multi-threaded task processing method, a task processing device, a computing device, and a computer-readable storage medium.

Background technique

With the continuous development of information technology, servers and storage devices need to handle high-concurrency services accompanied by massive IO. Therefore, server devices and storage devices have high requirements on performance and stability, and most scenarios are processed by multi-threads.

In related technologies, locking is required during multi-threaded access to public resources, but locking will introduce two problems: one is lock waiting, and the other is thread switching. Lock waiting will increase time-consuming, and thread switching will increase additional scheduling overhead. , these two problems have a great impact on performance, but not locking may cause data pollution, and thread safety cannot be guaranteed.

Therefore, how to avoid using the locking function to implement resource access is a major concern of those skilled in the art.

Contents of the invention

The purpose of this application is to provide a multi-thread task processing method, task processing device, computing equipment and computer-readable storage medium, so as to avoid the lock mechanism adopted to realize multi-thread task processing and improve the processing efficiency of multi-task.

In order to solve the above technical problems, the application provides a multithreaded task processing method, including:

Store the received tasks in the circular queue corresponding to the thread;

Dequeue the tasks in the circular queue in a first-in-first-out order;

Executing the task dequeued from the circular queue by the thread and the memory resource corresponding to the thread to obtain an execution result; wherein the memory resource is a memory resource applied for by the thread.

Optionally, the process of applying for the memory resource includes:

Send a memory application to the memory management module; wherein, the memory management module is used to manage the original memory pool;

The memory management module allocates memory space from the original memory pool, and returns memory information of the memory space;

The memory resource is determined based on the memory information.

Optionally, the memory management module allocates memory space from the original memory pool, and returns memory information of the memory space, including:

The memory management module allocates continuous memory space from the original memory pool;

Return the memory information of the memory space.

Optionally, the process of creating the circular queue includes:

Create a corresponding circular queue based on the multi-thread requirement information, and set the enqueue and dequeue operation instructions of the circular queue as a public interface.

Optionally, the process of creating the thread includes:

Create corresponding threads based on the quantity of the circular queue, and set the state of each thread as a resident thread.

Optionally, also include:

When the circular queue is an empty queue, control the thread corresponding to the circular queue to perform an idle operation.

Optionally, store the received tasks in the circular queue corresponding to the thread, including:

The sent task is stored in the circular queue through the enqueue operation interface of the circular queue.

The present application also provides a multi-threaded task processing device, including:

The task storage module is used to store the received tasks into the circular queue corresponding to the thread;

A circular queue processing module, configured to dequeue tasks in the circular queue in a first-in first-out order;

A task execution module, configured to execute the task dequeued from the circular queue through the thread and the memory resource corresponding to the thread, and obtain an execution result; wherein, the memory resource is a memory resource applied for the thread .

The present application also provides a computing device, comprising:

memory for storing computer programs;

A processor, configured to implement the steps of the above-mentioned task processing method when executing the computer program.

The present application also provides a computer-readable storage medium, where a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, the steps of the above-mentioned task processing method are realized.

A multi-threaded task processing method provided by the present application includes: storing the received tasks in the circular queue corresponding to the thread, and dequeuing the tasks in the circular queue in the order of first-in-first-out; through the thread and The memory resource corresponding to the thread executes the task dequeued from the circular queue, and obtains an execution result; wherein, the memory resource is a memory resource requested for the thread.

By storing the received tasks in the circular queue, the circular queue continues to dequeue the tasks in order. Finally, each time a task is dequeued, the corresponding thread and the memory resource corresponding to the thread execute the dequeued task and get executed. As a result, the thread uses the corresponding memory resources to execute tasks in order, avoiding the situation that tasks preempt resources and threads, so that multi-thread access is realized without using the lock mechanism, and the processing efficiency of multi-tasking is improved.

The present application also provides a multi-threaded task processing device, a computing device, and a computer-readable storage medium, which have the above beneficial effects, and will not be repeated here.

Description of drawings

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, the accompanying drawings in the following description are only It is an embodiment of the present application, and those skilled in the art can also obtain other drawings according to the provided drawings without creative work.

FIG. 1 is a flow chart of a multithreaded task processing method provided in an embodiment of the present application;

FIG. 2 is a data flow diagram of a multi-threaded task processing method provided by an embodiment of the present application;

FIG. 3 is a schematic diagram of memory management of a multi-threaded task processing method provided by an embodiment of the present application;

FIG. 4 is a schematic diagram of memory division of a multi-threaded task processing method provided by an embodiment of the present application;

FIG. 5 is a schematic diagram of a thread structure of a multi-threaded task processing method provided in an embodiment of the present application;

FIG. 6 is a schematic structural diagram of a multi-threaded task processing device provided by an embodiment of the present application;

FIG. 7 is a schematic structural diagram of a computing device provided by an embodiment of the present application.

Detailed ways

The core of the present application is to provide a multi-threaded task processing method, task processing device, computing device and computer-readable storage medium, so as to avoid the lock mechanism adopted to realize multi-threaded task processing and improve the processing efficiency of multi-task.

In order to make the purposes, technical solutions and advantages of the embodiments of the present application clearer, the technical solutions in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments It is a part of the embodiments of this application, not all of them. Based on the embodiments in this application, all other embodiments obtained by persons of ordinary skill in the art without making creative efforts belong to the scope of protection of this application.

In related technologies, locking is required during multi-threaded access to public resources, but locking will introduce two problems: one is lock waiting, and the other is thread switching. Lock waiting will increase time-consuming, and thread switching will increase additional scheduling overhead. , these two problems have a great impact on performance, but not locking may cause data pollution, and thread safety cannot be guaranteed.

Therefore, this application provides a multi-threaded task processing method, by storing the received tasks in the circular queue, and then the circular queue continues to dequeue the tasks in order, and finally each time a task is dequeued, the corresponding thread and The memory resource corresponding to the thread executes the dequeued task and obtains the execution result, which realizes that the thread uses the corresponding memory resource to execute the task in sequence, avoiding the situation where the task preempts resources and threads, and realizes multi-threading without using the lock mechanism Access to improve the processing efficiency of multitasking.

The following describes a multi-threaded task processing method provided by the present application through an embodiment.

Please refer to FIG. 1 , which is a flowchart of a multi-threaded task processing method provided by an embodiment of the present application.

In this embodiment, the method may include:

S101, storing the received task in the circular queue corresponding to the thread;

This step is to store the received tasks into the circular queue corresponding to the thread.

Wherein, the circular queue is mainly used for storing tasks, and the circular queue is a private queue for threads. Therefore, the tasks that the thread needs to process are only the tasks dequeued from the queue, avoiding the problem of threads preempted by multiple tasks.

Among them, there is a one-to-one correspondence between threads and circular queues, ensuring that there is no data exchange between threads.

Further, this step may include:

The sent tasks are stored in the circular queue through the enqueue operation interface of the circular queue.

It can be seen that this optional solution mainly explains how to store tasks in the circular queue. In this optional solution, the sent tasks are stored in the circular queue through the enqueue operation interface of the circular queue. That is, the circular queue has an enqueue operation interface for enqueue. Tasks can be stored in the circular queue through this enqueue operation interface. Correspondingly, the circular queue also includes a dequeue operation interface. Both the enqueue operation interface and the dequeue operation interface are public operation interfaces of the circular queue.

Further, the process of creating a circular queue in this embodiment may include:

Create a corresponding circular queue based on the multi-thread requirement information, and set the enqueue and dequeue operation instructions of the circular queue as a public interface.

It can be seen that this optional solution mainly explains how to create a circular queue. In this alternative solution, a corresponding circular queue is created based on the multi-thread requirement information, and the enqueue and dequeue operation instructions of the circular queue are set as a public interface. Since a circular queue corresponds to a queue. Therefore, in this optional solution, it is possible to determine how many circular queues to create based on the multi-thread requirement information. Wherein, the multi-thread requirement information is information indicating the required number of multi-threads.

Further, the process of creating a thread in this embodiment may include:

Create corresponding threads based on the number of circular queues, and set the status of each thread as a resident thread.

It can be seen that this optional solution mainly explains how to create corresponding threads. In this optional solution, you can create corresponding threads according to the number of circular queues. At the same time, set the status of each thread as a resident thread. Wherein, the resident process means that the process can be kept in the system regardless of whether the process has a task to execute, and the process does not need to be released because there is no task.

Further, on the basis of the previous option, this embodiment may also include:

When the circular queue is an empty queue, the thread corresponding to the control circular queue performs an idle operation.

It can be seen that this option mainly describes how to process when there is no task in the queue. In this optional scheme, when the circular queue is an empty queue, the thread corresponding to the control circular queue performs an idle operation.

S102, dequeue the tasks in the circular queue in the first-in-first-out order;

On the basis of S101, this step aims to dequeue the tasks in the circular queue in a first-in-first-out order.

That is to say, the tasks stored in the circular queue are dequeued in the first-in-first-out order. At the same time, the enqueue and dequeue operation can be set as a public interface to realize the operation of the thread on the circular queue. Furthermore, enqueue operations can be implemented in other modules, and the circular queue can be polled in the current module.

Furthermore, threads, queues, and other modules conform to the producer-consumer model. Threads, as consumers, dequeue elements after executing tasks, and other modules, as consumers, enqueue tasks to be processed.

S103. Execute the task dequeued from the circular queue through the thread and the memory resource corresponding to the thread, and obtain an execution result; wherein, the memory resource is a memory resource applied for by the thread.

On the basis of S102, this step aims to execute the task dequeued from the circular queue through the thread and the memory resource corresponding to the thread, and obtain the execution result; wherein, the memory resource is a memory resource applied for by the thread.

Wherein, the memory resource is a part of the memory resource corresponding to the thread. Other threads will not preempt memory resources and realize multi-threaded access.

Further, the process of applying for memory resources in this embodiment may include:

Step 1, sending a memory application to the memory management module; wherein, the memory management module is used to manage the original memory pool;

Step 2, the memory management module allocates memory space from the original memory pool, and returns the memory information of the memory space;

Step 3, determining the memory resource based on the memory information.

It can be seen that this option mainly describes how to apply for memory resources. In this optional solution, a memory application is sent to the memory management module; wherein, the memory management module is used to manage the original memory pool; the memory management module allocates memory space from the original memory pool, and returns the memory information of the memory space; determines based on the memory information memory resources.

Further, step 2 in the previous option may include:

Step 1, the memory management module allocates continuous memory space from the original memory pool;

Step 2, return the memory information of the memory space.

It can be seen that this optional solution mainly explains how to return memory information. In this optional solution, the memory management module allocates continuous memory space from the original memory pool; returns the memory information of the memory space.

To sum up, in this embodiment, the received tasks are stored in the circular queue, and then the circular queue continues to dequeue the tasks in order. Finally, each time a task is dequeued, the corresponding thread and the memory resource corresponding to the thread execute the dequeue. The task of the team can get the execution result, and realize that the thread uses the corresponding memory resource to execute the task in order, avoiding the situation that the task preempts the resource and the thread, so that the multi-thread access can be realized without using the lock mechanism, and the processing efficiency of the multi-task can be improved. .

A multi-threaded task processing method provided by the present application will be further described below through another specific embodiment.

Please refer to FIG. 2 . FIG. 2 is a data flow chart of a multi-threaded task processing method provided by an embodiment of the present application.

In this embodiment, the method may include:

Step 1, store the received task in the circular queue corresponding to the thread;

Step 2, dequeue the tasks in the circular queue in the order of first-in-first-out;

Step 3, execute the task dequeued from the circular queue through the thread and the memory resource corresponding to the thread, and obtain the execution result; wherein, the memory resource is the memory resource applied for by the thread.

Obviously, the above process stores the received tasks in the circular queue, and then the circular queue continues to dequeue the tasks in order. Finally, each time a task is dequeued, the corresponding thread and the memory resource corresponding to the thread execute the dequeue. Tasks, get the execution results, and realize that the threads use the corresponding memory resources to execute tasks in order, avoiding the situation where tasks preempt resources and threads, so that multi-thread access can be realized without using the lock mechanism, and the processing efficiency of multi-tasking can be improved.

Specifically, this embodiment uses the method of dividing the memory in advance to ensure that the exclusive thread accesses the exclusive resource and the thread polling circular queue, uses the circular queue as the unique task queue of the thread, and each thread polls its own private circular queue, and the shared resource Allocation according to private queues, overall planning of data structures, setting of thread private data, no thread communication and other methods can avoid frequent thread switching and lock waiting problems, and then realize that multi-threading can still ensure thread safety without locking. Reduce performance. This method is suitable for scenarios where multiple threads do not communicate with each other, and tasks are relatively independent and have high concurrency.

Please refer to FIG. 3 . FIG. 3 is a schematic diagram of memory management of a multi-threaded task processing method provided by an embodiment of the present application.

Among them, in the memory application process, a memory application module Memory Management (memory management module) is firstly created to realize the memory application interface of the kernel state and the memory application interface of the user state.

The memory application is divided into two categories, direct memory access and ordinary memory. Direct memory access is used for IO, does not require CPU participation, and reduces CPU usage, while ordinary memory requires CPU intervention.

Apply for memory in the system initialization phase, and do not apply for memory in the running phase. Calculate the memory size required by each module in advance. During initialization, the Memory Management module locks a large section of memory as the original memory pool. When other modules have memory request requirements, they send memory requests to the Memory Management module and inform them of the required memory type through the carried parameters. , the Memory Management module divides a block from the original memory pool (minimum allocation unit is 4k) and returns the memory information.

Further, memory application and release. After the memory application in the module is occupied for a long time, unless the module exits, the memory will be returned. The runtime of Memory Management does not release memory.

Among them, the size of the memory application can apply to the kernel for a 4K memory page to ensure continuous memory and facilitate memory offset operations.

Please refer to FIG. 4 , which is a schematic diagram of memory division of a multi-threaded task processing method provided by an embodiment of the present application.

Finally, memory partitioning between modules. As shown in Figure 4, each module divides the memory into several regions after obtaining the memory, and puts each region in a queue, and it is not allowed to put the same region in two queues.

Among them, thread and queue design:

The process of creating a circular queue can realize the enqueue and dequeue operation of the queue, and set the enqueue and dequeue operation as a public interface; implement the enqueue operation in other modules, and poll the queue in this module; when the circular queue is empty , it is considered that there is no task, and when it is not empty, the elements in the queue are processed sequentially, and the elements are dequeued after processing.

Please refer to FIG. 5 , which is a schematic diagram of a thread structure of a multi-threaded task processing method provided by an embodiment of the present application.

In the process of creating a thread queue, a corresponding number of threads can be created according to the number of queues. All threads are resident and will not be recycled or destroyed. Threads are allowed to idle when there is no task; the one-to-one correspondence between threads and queues is shown in Figure 5, ensuring that No data exchange between threads

Among them, threads, queues, and other modules conform to the producer-consumer model. Threads act as consumers and dequeue elements after executing tasks. Other modules act as consumers and enqueue tasks to be processed.

Finally, data structure and function design:

The definition of the data structure should be consistent with the thread ID. When other modules add tasks to the queue, ensure that the same block of memory is only executed in one queue.

If the number of data structures in each module is less than the number of threads, a certain number of threads is specified for processing. If it is greater than the number of threads, it can be evenly distributed among all threads depending on the situation and needs. If it is equal to the number of threads, it can be one-to-one.

A memory judgment operation is added to the function. As shown in Figure 2, function 0 may be executed on all threads. When the function is executed, the legality of the memory is judged first, and the execution is allowed only when it is legal.

It can be seen that this embodiment realizes the design of multi-threading without locking to ensure thread safety by pre-allocating memory and thread accessing exclusive resources, which can avoid frequent thread switching, lock waiting and other problems, improve movie star performance and stability, and improve product competitiveness. . Shared resources are divided in advance, and each thread accesses its own private data, thereby avoiding lock operations and realizing multi-thread without locking to ensure thread safety.

It can be seen that in this embodiment, the received tasks are stored in the circular queue, and then the circular queue continues to dequeue the tasks in order, and finally each time a task is dequeued, the corresponding thread and the memory resource corresponding to the thread execute the dequeue Tasks, execution results are obtained, threads use corresponding memory resources to execute tasks in sequence, avoiding tasks preempting resources and threads, enabling multi-threaded access without using a lock mechanism, and improving the processing efficiency of multi-tasking.

The multi-thread task processing device provided by the embodiment of the present application is introduced below. The multi-thread task processing device described below and the multi-thread task processing method described above can be referred to in correspondence.

Please refer to FIG. 6 , which is a schematic structural diagram of a multi-threaded task processing device provided by an embodiment of the present application.

In this embodiment, the device may include:

The task storage module 100 is used to store the received task into the circular queue corresponding to the thread;

The circular queue processing module 200 is used to dequeue the tasks in the circular queue according to the order of first-in-first-out;

The task execution module 300 is configured to execute the tasks dequeued from the circular queue through threads and memory resources corresponding to the threads, and obtain execution results; wherein, the memory resources are memory resources applied for by threads.

Optionally, this embodiment may further include: a memory application module, configured to send a memory application to the memory management module; wherein, the memory management module is used to manage the original memory pool; the memory management module allocates memory space from the original memory pool, and Returns the memory information of the memory space; determines memory resources based on the memory information.

Optionally, the memory management module allocates memory space from the original memory pool, and returns the memory information of the memory space, including:

The memory management module allocates continuous memory space from the original memory pool; returns the memory information of the memory space.

Optionally, this embodiment may further include: a queue application module, configured to create a corresponding circular queue based on multi-thread requirement information, and set the enqueue and dequeue operation instructions of the circular queue as a public interface.

Optionally, this embodiment may further include: a thread application module, configured to create corresponding threads based on the number of circular queues, and set the state of each thread as a resident thread.

Optionally, this embodiment may further include: an empty queue processing module, configured to control a thread corresponding to the circular queue to perform an idle operation when the circular queue is an empty queue.

Optionally, the task storage module 100 is specifically configured to store the sent task in the circular queue through the enqueue operation interface of the circular queue.

It can be seen that in this embodiment, the received tasks are stored in the circular queue, and then the circular queue continues to dequeue the tasks in order, and finally each time a task is dequeued, the corresponding thread and the memory resource corresponding to the thread execute the dequeue Tasks, execution results are obtained, threads use corresponding memory resources to execute tasks in sequence, avoiding tasks preempting resources and threads, enabling multi-threaded access without using a lock mechanism, and improving the processing efficiency of multi-tasking.

The present application also provides a computing device. Please refer to FIG. 7, which is a schematic structural diagram of a computing device provided in an embodiment of the present application. The computing device may include:

memory for storing computer programs;

The processor is used to implement the steps of any one of the above-mentioned multi-threaded task processing methods when executing a computer program.

As shown in FIG. 7 , which is a schematic structural diagram of a computing device, the computing device may include: a processor 10 , a memory 11 , a communication interface 12 and a communication bus 13 . The processor 10 , the memory 11 , and the communication interface 12 all communicate with each other through the communication bus 13 .

In the embodiment of the present application, the processor 10 may be a central processing unit (Central Processing Unit, CPU), an application-specific integrated circuit, a digital signal processor, a field programmable gate array, or other programmable logic devices.

The processor 10 can call the program stored in the memory 11, specifically, the processor 10 can execute the operations in the embodiment of the abnormal IP identification method.

The memory 11 is used to store one or more programs. The programs may include program codes, and the program codes include computer operation instructions. In the embodiment of the present application, the memory 11 stores at least programs for realizing the following functions:

Store the received tasks in the circular queue corresponding to the thread;

Dequeue the tasks in the circular queue in the order of first-in-first-out;

Execute the task dequeued from the circular queue through the thread and the memory resource corresponding to the thread, and obtain the execution result; wherein, the memory resource is the memory resource applied for by the thread.

In a possible implementation, the memory 11 may include a program storage area and a data storage area, wherein the program storage area may store an operating system and at least one application program required by a function; the data storage area may store The data created.

In addition, the memory 11 may include a high-speed random access memory, and may also include a non-volatile memory, such as at least one magnetic disk storage device or other volatile solid-state storage devices.

The communication interface 12 may be an interface of a communication module, and is used for connecting with other devices or systems.

Of course, it should be noted that the structure shown in FIG. 7 does not constitute a limitation on the computing device in the embodiment of the present application. In practical applications, the computing device may include more or less components than those shown in FIG. 7, or combine certain parts.

It can be seen that in this embodiment, the received tasks are stored in the circular queue, and then the circular queue continues to dequeue the tasks in order, and finally each time a task is dequeued, the corresponding thread and the memory resource corresponding to the thread execute the dequeue Tasks, execution results are obtained, threads use corresponding memory resources to execute tasks in sequence, avoiding tasks preempting resources and threads, enabling multi-threaded access without using a lock mechanism, and improving the processing efficiency of multi-tasking.

The present application also provides a computer-readable storage medium, on which a computer program is stored. When the computer program is executed by a processor, the steps of any one of the above-mentioned multi-threaded task processing methods can be realized.

The computer-readable storage medium may include: U disk, mobile hard disk, read-only memory (Read-Only Memory, ROM), random access memory (Random Access Memory, RAM), magnetic disk or optical disk, etc., which can store program codes. medium.

For the introduction of the computer-readable storage medium provided by the present application, please refer to the foregoing method embodiments, and the present application does not repeat it here.

It can be seen that in this embodiment, the received tasks are stored in the circular queue, and then the circular queue continues to dequeue the tasks in order, and finally each time a task is dequeued, the corresponding thread and the memory resource corresponding to the thread execute the dequeue Tasks, execution results are obtained, threads use corresponding memory resources to execute tasks in sequence, avoiding tasks preempting resources and threads, enabling multi-threaded access without using a lock mechanism, and improving the processing efficiency of multi-tasking.

Each embodiment in the description is described in a progressive manner, each embodiment focuses on the difference from other embodiments, and the same and similar parts of each embodiment can be referred to each other. As for the device disclosed in the embodiment, since it corresponds to the method disclosed in the embodiment, the description is relatively simple, and for relevant details, please refer to the description of the method part.

Professionals can further realize that the units and algorithm steps of the examples described in conjunction with the embodiments disclosed herein can be implemented by electronic hardware, computer software or a combination of the two. In order to clearly illustrate the possible For interchangeability, in the above description, the composition and steps of each example have been generally described according to their functions. Whether these functions are executed by hardware or software depends on the specific application and design constraints of the technical solution. Skilled artisans may use different methods to implement the described functions for each specific application, but such implementation should not be regarded as exceeding the scope of the present application.

The steps of the methods or algorithms described in connection with the embodiments disclosed herein may be directly implemented by hardware, software modules executed by a processor, or a combination of both. Software modules can be placed in random access memory (RAM), internal memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, removable disk, CD-ROM, or any other Any other known storage medium.

A multi-thread task processing method, a task processing device, a computing device, and a computer-readable storage medium provided in the present application have been introduced in detail above. In this paper, specific examples are used to illustrate the principles and implementation methods of the present application, and the descriptions of the above embodiments are only used to help understand the methods and core ideas of the present application. It should be pointed out that those skilled in the art can make some improvements and modifications to the application without departing from the principles of the application, and these improvements and modifications also fall within the protection scope of the claims of the application.

Claims (10)

1. A method for processing a task in a plurality of threads, comprising:

storing the received task to a circulation queue corresponding to the thread;

dequeuing tasks in the circular queue according to the first-in-first-out order;

executing the task queued from the cyclic queue through the thread and the memory resource corresponding to the thread to obtain an execution result; the memory resource is a memory resource applied for the thread.

2. The task processing method according to claim 1, wherein the process of applying for the memory resource includes:

sending a memory application to a memory management module; the memory management module is used for managing an original memory pool;

the memory management module allocates a memory space from the original memory pool and returns memory information of the memory space;

and determining the memory resource based on the memory information.

3. The task processing method according to claim 2, wherein the memory management module allocates a memory space from the original memory pool and returns memory information of the memory space, including:

the memory management module allocates continuous memory space from the original memory pool;

and returning the memory information of the memory space.

4. The task processing method according to claim 1, wherein the process of creating the circular queue includes:

and creating a corresponding circular queue based on the multithreading demand information, and setting the enqueue and dequeue operation instructions of the circular queue as a public interface.

5. The task processing method according to claim 1, wherein the process of creating the thread includes:

creating corresponding threads based on the number of the circular queues, and setting the state of each thread as a resident thread.

6. The task processing method according to claim 5, characterized by further comprising:

and when the circular queue is an empty queue, controlling the thread corresponding to the circular queue to execute idle operation.

7. The task processing method according to claim 1, wherein storing the received task in a circular queue corresponding to the thread, comprises:

and storing the sent task into the circular queue through an enqueue operation interface of the circular queue.

8. A multi-threaded task processing device, comprising:

the task storage module is used for storing the received task to a circulation queue corresponding to the thread;

the circular queue processing module is used for dequeuing tasks in the circular queue according to the first-in-first-out sequence;

the task execution module is used for executing the tasks listed from the cyclic queue through the threads and the memory resources corresponding to the threads to obtain an execution result; the memory resource is a memory resource applied for the thread.

9. A computing device, comprising:

a memory for storing a computer program;

a processor for implementing the steps of the task processing method according to any one of claims 1 to 7 when executing said computer program.

10. A computer-readable storage medium, on which a computer program is stored, which computer program, when being executed by a processor, implements the steps of the task processing method as claimed in any one of claims 1 to 7.

Images