CN112988365B - Thread management method, device, equipment and medium - Google Patents
Thread management method, device, equipment and medium Download PDFInfo
- Publication number
- CN112988365B CN112988365B CN202110555471.9A CN202110555471A CN112988365B CN 112988365 B CN112988365 B CN 112988365B CN 202110555471 A CN202110555471 A CN 202110555471A CN 112988365 B CN112988365 B CN 112988365B
- Authority
- CN
- China
- Prior art keywords
- thread
- threads
- running
- function
- callback
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
- G06F9/485—Task life-cycle, e.g. stopping, restarting, resuming execution
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/3017—Runtime instruction translation, e.g. macros
Abstract
The embodiment of the disclosure relates to a thread management method, a device, equipment and a medium, which are applied to a macro kernel operating system, wherein a system service thread in the macro kernel operating system is represented in a callback function mode, and the method comprises the following steps: generating corresponding callback functions based on the thread functions of the system service threads, and embedding the callback functions into the main thread; when the main thread starts to run, other threads in a running state are locked; and after the main thread finishes running, calling a callback function to execute the thread function of the corresponding system service thread. According to the method, the callback function is adopted to replace the system service thread, the function of the system service thread can be realized by means of the callback function, and other running threads can be locked when the main thread runs, so that the main thread monopolizes system resources, the resources are concentrated to complete a core task, and the callback function is called to execute the thread function of the system service thread after the completion, so that the stable running of the system is well guaranteed.
Description
Technical Field
The present disclosure relates to the field of computer technologies, and in particular, to a method, an apparatus, a device, and a medium for thread management.
Background
The thread management method of the current macro kernel operating system (also referred to as macro kernel for short) has certain problems, for example, in order to ensure system stability, the macro kernel usually sets that a system service thread needs to be kept in a running state all the time, that is, the system cannot be locked (otherwise, the system is crashed), only a non-system service thread can be locked, and the characteristic that the system service thread cannot be locked in the macro kernel causes that a main thread executing an important task cannot monopolize the whole system resource to run.
Disclosure of Invention
To solve the technical problem or at least partially solve the technical problem, the present disclosure provides a thread management method, apparatus, device and medium.
The embodiment of the disclosure provides a thread management method, which is applied to a macro kernel operating system, and a system service thread in the macro kernel operating system is characterized in a callback function form, wherein the method comprises the following steps: generating corresponding callback functions based on the thread functions of the system service threads, and embedding the callback functions into the main thread; when the main thread starts to run, locking other threads in a running state; and calling the callback function to execute the thread function of the corresponding system service thread after the main thread is operated.
In some embodiments, the step of locking other threads in a running state comprises: and locking other threads in a running state by a software triggered interrupt mode.
In some embodiments, the step of locking other threads in a running state by means of a software-triggered interrupt includes: sending an interrupt instruction to the central processing units to which other threads in the running state belong; the interrupt instruction carries an interrupt number; calling an interrupt processing program corresponding to the interrupt number through the central processing unit to move the other threads in the running state out of the running state queue to a target state queue; the target state queue comprises a pending queue or a sleeping queue.
In some embodiments, the method further comprises: and after the main thread finishes running, restoring the original states of other threads locked by the running of the main thread.
In some embodiments, the core function of the main thread has a higher priority than the callback function embedded within the main thread.
The embodiment of the present disclosure further provides a thread management apparatus, where the apparatus is applied to a macro kernel operating system, and a system service thread in the macro kernel operating system is characterized in a form of a callback function, and the apparatus includes: the callback function embedding module is used for generating corresponding callback functions based on the thread functions of the system service threads and embedding the callback functions into the main thread; the thread locking module is used for locking other threads in a running state when the main thread starts running; and the callback function execution module is used for calling the callback function to execute the thread function of the corresponding system service thread after the main thread finishes running.
In some embodiments, the thread locking module is further configured to: and locking other threads in a running state by a software triggered interrupt mode.
In some embodiments, the apparatus further comprises: and the thread recovery module is used for recovering the original states of other threads locked due to the running of the main thread after the running of the main thread is finished.
An embodiment of the present disclosure further provides an electronic device, which includes: a processor; a memory for storing the processor-executable instructions; the processor is used for reading the executable instruction from the memory and executing the instruction to realize the thread management method provided by the embodiment of the disclosure.
The embodiment of the present disclosure also provides a computer-readable storage medium, where a computer program is stored, where the computer program is used to execute the thread management method provided by the embodiment of the present disclosure.
According to the technical scheme provided by the embodiment of the disclosure, the macro kernel operating system is improved to a certain extent, the system service threads in the macro kernel operating system are represented in a callback function mode, firstly, corresponding callback functions are generated based on the thread functions of the system service threads, and the callback functions are embedded into the main thread; when the main thread starts to run, other threads in a running state are locked through an interrupt instruction; and after the main thread finishes running, calling a callback function to execute the thread function of the corresponding system service thread. According to the mode, the callback function is adopted to replace the system service thread, the function of the system service thread can be realized by means of the callback function, the problem that the system service thread cannot be locked in the related technology is solved, other running threads can be locked when the main thread runs, the main thread monopolizes system resources, the core task is completed by concentrating the resources, the callback function is called to execute the thread function of the system service thread after the core task is completed, and the stability of the system is well guaranteed.
It should be understood that the statements in this section do not necessarily identify key or critical features of the embodiments of the present disclosure, nor do they limit the scope of the present disclosure. Other features of the present disclosure will become apparent from the following description.
Drawings
The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present disclosure and together with the description, serve to explain the principles of the disclosure.
In order to more clearly illustrate the embodiments or technical solutions in the prior art of the present disclosure, the drawings used in the description of the embodiments or prior art will be briefly described below, and it is obvious for those skilled in the art that other drawings can be obtained according to the drawings without inventive exercise.
Fig. 1 is a schematic flowchart of a thread management method according to an embodiment of the disclosure;
fig. 2 is a schematic structural diagram of a thread management device according to an embodiment of the present disclosure;
fig. 3 is a schematic structural diagram of another thread management apparatus according to an embodiment of the present disclosure;
fig. 4 is a schematic structural diagram of an electronic device according to an embodiment of the present disclosure.
Detailed Description
In order that the above objects, features and advantages of the present disclosure may be more clearly understood, aspects of the present disclosure will be further described below. It should be noted that the embodiments and features of the embodiments of the present disclosure may be combined with each other without conflict.
In the following description, numerous specific details are set forth in order to provide a thorough understanding of the present disclosure, but the present disclosure may be practiced in other ways than those described herein; it is to be understood that the embodiments disclosed in the specification are only a few embodiments of the present disclosure, and not all embodiments.
The macro Kernel is also called a single Kernel, and is a kind of Kernel architecture of an operating system, and the feature of the architecture is that the whole Kernel runs in a Kernel Space (Kernel Space) identity and Supervisor Mode (hypervisor Mode). Generally, a macro kernel includes multiple threads, which mainly include a user thread and a kernel thread, but in the related art, a system service thread (belonging to the kernel thread) in the macro kernel is set to be required to always maintain a running state, and if the system service thread is suspended or terminated, the system may be crashed. Therefore, only non-system service threads can be locked, but all running threads cannot be locked simultaneously due to the existence of the system service threads, so that a main thread executing an important task cannot monopolize the whole system resource to run, and in addition, the macro kernel in the related art has the problem that the state of a control thread has a long time delay due to the adoption of a signal mechanism.
Fig. 1 is a schematic flow chart of a thread management method provided in an embodiment of the present disclosure, where the method is applied to a macro kernel operating system, and a system service thread in the macro kernel operating system is represented in a callback function manner, that is, in the macro kernel operating system in an embodiment of the present disclosure, the system service thread is replaced by the callback function, so as to avoid the system service thread from occupying a central processing unit resource, but the function of the corresponding system service thread can be executed through the callback function, so as to ensure stable operation of the system, and specifically, as shown in fig. 1, the method mainly includes the following steps S102 to S106:
and S102, generating corresponding callback functions based on the thread functions of the system service threads, and embedding the callback functions into the main thread. The main thread may also be referred to as a main task thread.
It is understood that the macro kernel includes various service threads for maintaining the operation of the system, and each system service thread has a corresponding thread function, such as, for example, taking the system service thread as a kernel scheduling thread, the thread function is mainly to implement thread scheduling. In the embodiment of the present disclosure, a corresponding callback function is generated based on a thread function, each system service thread corresponds to a callback function, and the generated callback function may be further made into a callback function table and embedded into a main thread for calling. The form of the callback function may be specifically set according to actual conditions, and is not limited herein.
In some embodiments, the priority of the kernel function of the main thread is higher than that of the callback function embedded in the main thread, and the kernel function is also called the main function of the main thread, and may be determined according to the thread task of the main thread, which is not limited herein. The core function of the main thread is executed preferentially, the main thread can be guaranteed to utilize system resources to process tasks in a centralized mode, and then the function of the callback function (namely the function of the corresponding system service thread) is executed after the core function is executed, so that the main thread is guaranteed to run stably.
And step S104, when the main thread starts to run, locking other threads in a running state. Locking a thread, that is, making the thread no longer in a running state, may be implemented in a manner of changing the thread in the running state into a suspended state or a sleeping state, in an embodiment.
In consideration of the problems of long time delay and the like in the mode of managing and controlling the thread state by adopting a signal mechanism in the related art, the embodiment of the disclosure can lock other threads in the running state by a software triggered interrupt mode. The delay can be reduced by means of software triggered interrupts compared to signal controlled approaches, since signals involve transfer delays, whereas software triggered interrupts respond immediately.
And step S106, after the main thread is operated, calling a callback function to execute the thread function of the corresponding system service thread. The callback function has the corresponding thread function of the system service thread, so that the system can be continuously ensured to stably run.
According to the mode provided by the embodiment of the disclosure, the callback function is adopted to replace the system service thread, the function of the system service thread can be realized by means of the callback function, and the problem that the system service thread cannot be locked in the related technology is solved, so that other running threads can be locked when the main thread runs, the main thread monopolizes system resources, the resources are concentrated to complete core tasks, and the callback function is called to execute the thread function of the system service thread after the completion, so that the system stability is well guaranteed.
In some embodiments, the specific steps for locking up other threads in a running state by means of software-triggered interrupt may be performed with reference to the following steps a to b:
step a, sending an interrupt instruction to a Central Processing Unit (CPU) to which other threads in a running state belong; the interrupt instruction carries an interrupt number. It is understood that, when the interrupt numbers are different, the corresponding interrupt modes are also different, in other words, the interrupt numbers are used to indicate the interrupt modes, and the interrupt modes can be implemented by interrupt handlers, that is, each interrupt number corresponds to one interrupt handler. The interrupt handler can be characterized by an interrupt response function. In practical application, an interrupt table may be established in advance, and the interrupt table records the corresponding relationship between the interrupt number and the interrupt response function. For other threads in the running state, the interrupt numbers corresponding to different threads are different, so that the corresponding interrupt mode can be determined according to the self condition of each thread in the running state, and the interrupt instruction carrying the matched interrupt number can be sent in a targeted manner.
B, calling an interrupt handler corresponding to the interrupt number by the central processing unit to remove other threads in the running state from the running state queue to a target state queue (also called as a target queue); the target state queue includes a pending queue or a sleeping queue. That is, changing a thread in a running state to a suspend state or a sleep state, the thread is considered locked, which may also be referred to as causing the thread to relinquish the CPU.
It will be appreciated that a thread has mainly the following states: sleep state, suspend state, ready state, and run state. If the thread is in the sleep state, the thread is represented to be in the sleep queue and is awakened within the designated time; if the thread is in the suspended state, the thread is represented to be in a suspended queue and can be awakened at any time; if the thread is in the ready state, the thread is represented to be in a ready queue to wait for running; and if the thread is in the running state, the thread is represented to be in a running queue and is running. The thread state may be changed by placing the thread in a different queue.
In addition, the method further comprises: and after the main thread finishes running, restoring the original states of other threads locked by the running of the main thread. That is, other locked threads are restored to their original running states. After the core function of the main thread is completed, the unlocking operation can be executed on other threads, and the original states of the other threads are recovered.
In the disclosed embodiment, a thread may be changed to a suspended state as follows: for the thread in the sleep state or the blocking state, the state of the thread can be directly changed into a suspended state; for the thread in the running state, an interrupt instruction can be sent to the CPU where the thread is located, the thread is modified into a suspended state through an interrupt handler (interrupt response function) corresponding to the interrupt instruction, and the CPU is abandoned. During scheduling, the thread in the suspended state can be changed into a non-suspended state, such as a running state, and the thread is added into the running queue to be scheduled to run in real time.
To sum up, according to the thread management method provided by the embodiment of the present disclosure, by replacing the function of the system service thread with the callback function, the main thread can lock other running threads during running, so that the main thread can monopolize system resources, concentrate resources to complete a core task, and then call the callback function to execute the thread function of the system service thread, thereby ensuring system stability. In addition, when the thread is controlled, the embodiment of the disclosure can replace a signal mechanism in the related art by a software-triggered interrupt mode, thereby improving the problems of signal delay time and the like when the thread state is changed in the related art, and better ensuring the real-time performance of thread control.
Corresponding to the foregoing thread management method, an embodiment of the present disclosure provides a thread management apparatus, where the apparatus is applied to a macro kernel operating system, and a system service thread in the macro kernel operating system is characterized in a form of a callback function, fig. 2 is a schematic structural diagram of the thread management apparatus provided in the embodiment of the present disclosure, and the apparatus may be implemented by software and/or hardware, and may be generally integrated in an electronic device, as shown in fig. 2, and includes:
the callback function embedding module 202 is used for generating corresponding callback functions based on the thread functions of the system service threads and embedding the callback functions into the main thread;
a thread locking module 204, configured to lock other threads in a running state through an interrupt instruction when the main thread starts running;
and the callback function execution module 206 is configured to call the callback function to execute a thread function of the corresponding system service thread after the main thread is finished running.
According to the device provided by the embodiment of the disclosure, the callback function is adopted to replace the system service thread, the function of the system service thread can be realized by means of the callback function, the problem that the system service thread cannot be locked in the related technology is solved, so that other running threads can be locked when the main thread runs, the main thread monopolizes system resources, the resources are concentrated to complete core tasks, and the callback function is called to execute the thread function of the system service thread after the completion, so that the system stability is well guaranteed.
In some embodiments, the lock thread module 204 is further configured to: other threads in the running state are locked by an interrupt instruction.
In some embodiments, the lock thread module 204 is further configured to: sending an interrupt instruction to the central processing units to which other threads in the running state belong; the interrupt instruction carries an interrupt number; calling an interrupt processing program corresponding to the interrupt number through the central processing unit to move other threads in the running state out of the running state queue to the target state queue; the target state queue includes a pending queue or a sleeping queue.
The embodiment of the present disclosure provides a schematic structural diagram of another thread management apparatus as shown in fig. 3, where the apparatus further includes, on the basis of fig. 2: the thread restoring module 302 is configured to restore an original state of the other threads locked due to the running of the main thread after the running of the main thread is finished.
In some embodiments, the core function of the main thread has a higher priority than the callback function embedded within the main thread.
The thread management device provided by the embodiment of the disclosure can execute the thread management method provided by any embodiment of the disclosure, and has corresponding functional modules and beneficial effects of the execution method.
It can be clearly understood by those skilled in the art that, for convenience and brevity of description, the specific working processes of the above-described apparatus embodiments may refer to corresponding processes in the method embodiments, and are not described herein again.
An embodiment of the present disclosure further provides an electronic device, including: a processor; a memory for storing processor-executable instructions; and the processor is used for reading the executable instructions from the memory and executing the instructions to realize any thread management method. Fig. 4 is a schematic structural diagram of an electronic device according to an embodiment of the present disclosure. As shown in fig. 4, the electronic device 400 includes one or more processors 401 and memory 402.
The processor 401 may be a Central Processing Unit (CPU) or other form of processing unit having data processing capabilities and/or instruction execution capabilities, and may control other components in the electronic device 400 to perform desired functions.
In one example, the electronic device 400 may further include: an input device 403 and an output device 404, which are interconnected by a bus system and/or other form of connection mechanism (not shown).
The input device 403 may also include, for example, a keyboard, a mouse, and the like.
The output device 404 may output various information to the outside, and the output device 404 may include, for example, a display, a speaker, a printer, and a communication network and a remote output apparatus connected thereto, and the like.
Of course, for simplicity, only some of the components of the electronic device 400 relevant to the present disclosure are shown in fig. 4, omitting components such as buses, input/output interfaces, and the like. In addition, electronic device 400 may include any other suitable components depending on the particular application.
In addition to the above methods and apparatus, embodiments of the present disclosure may also be a computer program product comprising computer program instructions that, when executed by a processor, cause the processor to perform the thread management methods provided by embodiments of the present disclosure.
The computer program product may write program code for carrying out operations for embodiments of the present disclosure in any combination of one or more programming languages, including an object oriented programming language such as Java, C + + or the like 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 computing device, partly on the user's device, as a stand-alone software package, partly on the user's computing device and partly on a remote computing device, or entirely on the remote computing device or server.
The computer-readable storage medium may take any combination of one or more readable media. The readable medium may be a readable signal medium or a readable storage medium. A readable storage medium may include, 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 (a non-exhaustive list) of the readable storage medium include: an electrical connection having one or more wires, a portable disk, 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.
Embodiments of the present disclosure also provide a computer program product comprising a computer program/instructions that, when executed by a processor, implement a thread management method in embodiments of the present disclosure.
It is noted that, in this document, relational terms such as "first" and "second," and the like, may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other identical elements in a process, method, article, or apparatus that comprises the element.
The foregoing are merely exemplary embodiments of the present disclosure, which enable those skilled in the art to understand or practice the present disclosure. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other embodiments without departing from the spirit or scope of the disclosure. Thus, the present disclosure is not intended to be limited to the embodiments shown herein but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.
Claims (8)
1. A thread management method is applied to a macro kernel operating system, and system service threads in the macro kernel operating system are characterized in the form of callback functions, and the method comprises the following steps:
generating corresponding callback functions based on the thread functions of the system service threads, and embedding the callback functions into the main thread;
when the main thread starts to run, locking other threads in a running state;
after the main thread is operated, calling the callback function to execute the thread function of the corresponding system service thread;
the step of locking other threads in the running state comprises the following steps:
and locking other threads in a running state by a software triggered interrupt mode.
2. The thread management method of claim 1, wherein the step of locking down other running threads by means of a software-triggered interrupt comprises:
sending an interrupt instruction to the central processing units to which other threads in the running state belong; the interrupt instruction carries an interrupt number;
calling an interrupt processing program corresponding to the interrupt number through the central processing unit to move the other threads in the running state out of the running state queue to a target state queue; the target state queue comprises a pending queue or a sleeping queue.
3. The thread management method of claim 1, wherein the method further comprises:
and after the main thread finishes running, restoring the original states of other threads locked by the running of the main thread.
4. The thread management method of claim 1, wherein the priority of the core function of the main thread is higher than the priority of the callback function embedded in the main thread.
5. A thread management device, which is applied to a macro kernel operating system, and a system service thread in the macro kernel operating system is characterized in the form of a callback function, the device comprises:
the callback function embedding module is used for generating corresponding callback functions based on the thread functions of the system service threads and embedding the callback functions into the main thread;
the thread locking module is used for locking other threads in a running state when the main thread starts running;
the callback function execution module is used for calling the callback function to execute the thread function of the corresponding system service thread after the main thread finishes running;
the lock thread module is further to:
and locking other threads in a running state by a software triggered interrupt mode.
6. The thread management apparatus of claim 5, wherein the apparatus further comprises:
and the thread recovery module is used for recovering the original states of other threads locked due to the running of the main thread after the running of the main thread is finished.
7. An electronic device, characterized in that the electronic device comprises:
a processor;
a memory for storing the processor-executable instructions;
the processor is configured to read the executable instructions from the memory and execute the instructions to implement the thread management method of any of claims 1-4.
8. A computer-readable storage medium, characterized in that the storage medium stores a computer program for executing the thread management method of any of the preceding claims 1-4.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110555471.9A CN112988365B (en) | 2021-05-21 | 2021-05-21 | Thread management method, device, equipment and medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110555471.9A CN112988365B (en) | 2021-05-21 | 2021-05-21 | Thread management method, device, equipment and medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112988365A CN112988365A (en) | 2021-06-18 |
| CN112988365B true CN112988365B (en) | 2021-09-14 |
Family
ID=76337102
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110555471.9A Active CN112988365B (en) | 2021-05-21 | 2021-05-21 | Thread management method, device, equipment and medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112988365B (en) |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN106250244A (en) * | 2016-07-15 | 2016-12-21 | 北京金山安全软件有限公司 | Method and device for releasing mutual exclusion lock and electronic equipment |
| US10776161B2 (en) * | 2018-11-30 | 2020-09-15 | Oracle International Corporation | Application code callbacks at regular intervals |
Family Cites Families (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JP3807588B2 (en) * | 1999-08-12 | 2006-08-09 | 富士通株式会社 | Multi-thread processing apparatus, processing method, and computer-readable recording medium storing multi-thread program |
| CN101030152A (en) * | 2007-03-20 | 2007-09-05 | 华为技术有限公司 | Operation controller and controlling method based on pseudo-clock mode |
| US20090228904A1 (en) * | 2008-03-04 | 2009-09-10 | Microsoft Corporation | Declarative support for asynchronous methods |
| CN103345422B (en) * | 2013-07-02 | 2019-01-29 | 厦门雅迅网络股份有限公司 | A kind of multithreading hard real-time control method based on Linux |
| CN106453642A (en) * | 2016-11-28 | 2017-02-22 | 国网四川省电力公司眉山供电公司 | Linux dynamic link library-based method of rapidly upgrading electric energy data acquire terminal |
-
2021
- 2021-05-21 CN CN202110555471.9A patent/CN112988365B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN106250244A (en) * | 2016-07-15 | 2016-12-21 | 北京金山安全软件有限公司 | Method and device for releasing mutual exclusion lock and electronic equipment |
| US10776161B2 (en) * | 2018-11-30 | 2020-09-15 | Oracle International Corporation | Application code callbacks at regular intervals |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112988365A (en) | 2021-06-18 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| TW490638B (en) | Computer for executing plural operating systems | |
| KR20210045299A (en) | Long running workflows for document processing using robotic process automation | |
| US7562362B1 (en) | User control of task priority | |
| CN102508716B (en) | Task control device and task control method | |
| US20120260257A1 (en) | Scheduling threads in multiprocessor computer | |
| CN107491346B (en) | Application task processing method, device and system | |
| WO2009147802A1 (en) | Priority controller and priority control method | |
| US10229077B2 (en) | Method for data transfer between real-time tasks using a DMA memory controller | |
| CN113010275B (en) | Interrupt processing method and device | |
| US20040117793A1 (en) | Operating system architecture employing synchronous tasks | |
| TWI394074B (en) | Methods, apparatus and computer programs for managing access to storage | |
| CN110971700B (en) | Method and device for realizing distributed lock | |
| EP1693743A2 (en) | System, method and medium for using and/or providing operating system information to acquire a hybrid user/operating system lock | |
| CN111666141A (en) | Task scheduling method, device and equipment and computer storage medium | |
| US20180203743A1 (en) | Maintaining the responsiveness of a user interface while performing a synchronous operation | |
| JP4992740B2 (en) | Multiprocessor system, failure detection method, and failure detection program | |
| CN112988365B (en) | Thread management method, device, equipment and medium | |
| US7797473B2 (en) | System for executing system management interrupts and methods thereof | |
| WO2023241307A1 (en) | Method and apparatus for managing threads | |
| US20060288049A1 (en) | Method, System and computer Program for Concurrent File Update | |
| TW200905567A (en) | Notifying user mode scheduler of blocking events | |
| CN107632893B (en) | Message queue processing method and device | |
| CN111563000B (en) | File generation method, intelligent terminal and storage medium | |
| CN115904644A (en) | Task scheduling method, electronic device and computer program product | |
| US10303513B2 (en) | Durable program execution |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |