CN113485840A - Multi-task parallel processing device and method based on Go language - Google Patents
Multi-task parallel processing device and method based on Go language Download PDFInfo
- Publication number
- CN113485840A CN113485840A CN202110851044.5A CN202110851044A CN113485840A CN 113485840 A CN113485840 A CN 113485840A CN 202110851044 A CN202110851044 A CN 202110851044A CN 113485840 A CN113485840 A CN 113485840A
- Authority
- CN
- China
- Prior art keywords
- coroutine
- channel buffer
- buffer area
- main thread
- language
- 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.)
- Pending
Links
- 238000012545 processing Methods 0.000 title claims abstract description 57
- 238000000034 method Methods 0.000 title claims abstract description 25
- 238000004590 computer program Methods 0.000 claims description 18
- 238000003672 processing method Methods 0.000 claims description 18
- 238000003860 storage Methods 0.000 claims description 9
- 230000008569 process Effects 0.000 abstract description 8
- 238000005516 engineering process Methods 0.000 abstract description 2
- 238000010586 diagram Methods 0.000 description 14
- 238000004891 communication Methods 0.000 description 10
- 238000004364 calculation method Methods 0.000 description 7
- 230000000903 blocking effect Effects 0.000 description 4
- 230000006870 function Effects 0.000 description 4
- 230000008901 benefit Effects 0.000 description 3
- 230000005540 biological transmission Effects 0.000 description 3
- 230000007246 mechanism Effects 0.000 description 3
- 230000009286 beneficial effect Effects 0.000 description 2
- 230000002159 abnormal effect Effects 0.000 description 1
- 230000015556 catabolic process Effects 0.000 description 1
- 238000006731 degradation reaction Methods 0.000 description 1
- 238000001514 detection method Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000004904 shortening Methods 0.000 description 1
- 230000004622 sleep time Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
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/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
Abstract
The invention provides a multi-task parallel processing device and a method based on Go language, which can be used in the field of distributed technology and is used for the device comprising: the main thread module is used for initializing a channel buffer area and declaring the data type transmitted by the channel buffer area; establishing a plurality of cooperation processes concurrently, and transmitting the channel buffer area serving as a parameter to the plurality of cooperation processes; reading a channel buffer area, obtaining a coroutine service processing result, executing a main thread service logic, and obtaining a summary result; and the protocol module is used for executing the service logic of each protocol after each protocol is established and writing the service processing result of each protocol into the channel buffer area. The invention can carry out multi-task summary processing and has high efficiency.
Description
Technical Field
The invention relates to the field of distributed technology, in particular to a multi-task parallel processing device and method based on Go language.
Background
In a single-machine application program, when one parent task (main thread) has a plurality of subtasks (sub threads), under the condition that data sharing among the threads is realized without depending on other middleware systems (cache, database and the like), communication among the threads cannot be realized, and the main thread cannot obtain the calculation result of the sub threads.
Disclosure of Invention
The embodiment of the invention provides a multi-task parallel processing device based on Go language, which is used for multi-task summary processing and has high efficiency, and the device comprises:
the main thread module is used for initializing a channel buffer area and declaring the data type transmitted by the channel buffer area; establishing a plurality of cooperation processes concurrently, and transmitting the channel buffer area serving as a parameter to the plurality of cooperation processes; reading a channel buffer area, obtaining a coroutine service processing result, executing a main thread service logic, and obtaining a summary result;
and the protocol module is used for executing the service logic of each protocol after each protocol is established and writing the service processing result of each protocol into the channel buffer area.
The embodiment of the invention provides a multi-task parallel processing method based on Go language, which is used for multi-task summary processing and has high efficiency, and the method comprises the following steps:
initializing a channel buffer area by using a main thread, and declaring the data type transmitted by the channel buffer area; concurrently establishing a plurality of coroutines, and transmitting the channel buffer area as a parameter to the plurality of coroutines, wherein the main thread is used for executing a father task, and each coroutine is used for executing each subtask;
executing the service logic of each coroutine and writing the service processing result of each coroutine into a channel buffer area;
and reading the channel buffer area by using the main thread, obtaining a service processing result of the coroutine, executing the service logic of the main thread, and obtaining a summary result.
The embodiment of the invention also provides computer equipment which comprises a memory, a processor and a computer program which is stored on the memory and can run on the processor, wherein when the processor executes the computer program, the multi-task parallel processing method based on the Go language is realized.
An embodiment of the present invention further provides a computer-readable storage medium, where a computer program for executing the above-mentioned Go language-based multitask parallel processing method is stored in the computer-readable storage medium.
In the embodiment of the present invention, the main thread module is configured to initialize a channel buffer and declare a data type transmitted by the channel buffer; concurrently establishing a plurality of coroutines, and transmitting the channel buffer area as a parameter to the plurality of coroutines, wherein the main thread is used for executing a father task, and each coroutine is used for executing each subtask; reading a channel buffer area, obtaining a coroutine service processing result, executing a main thread service logic, and obtaining a summary result; and the protocol module is used for executing the service logic of each protocol after each protocol is established and writing the service processing result of each protocol into the channel buffer area. In the process, a plurality of subtasks can be processed in parallel, and the parent task can communicate with the subtasks, namely, the tasks can be processed in a blocking mode to wait for all subtasks to complete calculation and collect results, so that the task processing efficiency is improved, and the processing time is shortened.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only some embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to the drawings without creative efforts. In the drawings:
FIG. 1 is a schematic diagram of a multi-task parallel processing device based on Go language according to an embodiment of the present invention;
FIG. 2 is a schematic diagram of a main thread and multiple coroutines communicating in an embodiment of the invention;
FIG. 3 is a flowchart of a multi-task parallel processing method based on Go language according to an embodiment of the present invention;
FIG. 4 is a detailed flowchart of a multi-task parallel processing method based on Go language in the embodiment of the present invention;
FIG. 5 is a diagram of a computer device in an embodiment of the invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the embodiments of the present invention more apparent, the embodiments of the present invention are further described in detail below with reference to the accompanying drawings. The exemplary embodiments and descriptions of the present invention are provided to explain the present invention, but not to limit the present invention.
In the description of the present specification, the terms "comprising," "including," "having," "containing," and the like are used in an open-ended fashion, i.e., to mean including, but not limited to. Reference to the description of the terms "one embodiment," "a particular embodiment," "some embodiments," "for example," etc., means that a particular feature, structure, or characteristic described in connection with the embodiment or example is included in at least one embodiment or example of the application. In this specification, the schematic representations of the terms used above do not necessarily refer to the same embodiment or example. Furthermore, the particular features, structures, or characteristics described may be combined in any suitable manner in any one or more embodiments or examples. The sequence of steps involved in the embodiments is for illustrative purposes to illustrate the implementation of the present application, and the sequence of steps is not limited and can be adjusted as needed.
Terms related to the embodiments of the present invention are explained first.
The Go language: the programming language published by google in 2009 is characterized by better support for multi-thread programming and is very suitable for development of high-concurrency systems.
Coroutine (gorutine): the greatest advantage of the coroutine of the Go language over traditional system level threads and processes is its "lightweight" nature, which can easily create millions without causing system resource degradation.
channel: the channel is a communication mode between the goroutines provided by Go language at the language level. A channel may be used to pass messages between two or more goroutines. A channel can only carry values of one type, which needs to be specified when a channel is declared. Writing data to a channel typically causes program blocking until another goroutine reads data from the channel; reading data from a channel also causes program blocking until the channel is written with data if the channel has not been previously written with data.
Fig. 1 is a schematic diagram of a multi-task parallel processing apparatus based on Go language in an embodiment of the present invention, as shown in fig. 1, the apparatus includes:
the main thread module 101 is configured to initialize a channel buffer and declare a data type transmitted by the channel buffer; concurrently establishing a plurality of coroutines, and transmitting the channel buffer area as a parameter to the plurality of coroutines, wherein the main thread is used for executing a father task, and each coroutine is used for executing each subtask; reading a channel buffer area, obtaining a coroutine service processing result, executing a main thread service logic, and obtaining a summary result;
the coroutine module 102 is configured to execute the service logic of each coroutine after each coroutine is established, and write the service processing result of each coroutine into the channel buffer.
In the above embodiment, multiple subtasks may be processed in parallel, and the parent task may communicate with the subtasks, that is, may wait for all subtasks to complete the calculation in a blocking manner and summarize the result, thereby improving the task processing efficiency and shortening the processing time.
The channel buffer is blocked when being read, even if no reading party exists, the writing party can write into the channel buffer all the time, the writing party cannot block until the channel buffer is filled up, and the writing party blocks and waits if the channel buffer is filled up. In the above embodiment, the main thread module executes the main thread logic once every time it reads a service processing result, without waiting for all coroutines to complete. The aggregated results are updated in real-time. After the summary result is obtained, the go language internal mechanism deletes the read service processing result from the channel buffer.
The main thread module declares the type of data (e.g., numbers, strings, or other types) it delivers after initializing a channel buffer.
In one embodiment, the size of the channel buffer is the number of CPU cores. In this way, maximum use can be made of the computer performance.
Fig. 2 is a schematic diagram of communication between a main thread and multiple coroutines in an embodiment of the present invention, where the main thread module is further configured to:
initializing a counter variable; after a service processing result of one coroutine is read from a channel buffer area, adding 1 to the counter variable; and judging whether the counter variable is consistent with the coroutine total number or not, if so, outputting a summary result, and if not, continuing to wait for reading a service processing result from the channel buffer area.
In the above embodiment, the counter variable counter has an initial value of 0, and is used to count the number of coroutines completed.
In one embodiment, the coroutine module is further configured to:
for each coroutine, after the coroutine is established, starting an exception handling subprocess, and writing an overtime signal corresponding to the coroutine into a channel after the exception handling subprocess has a preset time length;
the main thread module is further configured to: and after reading the overtime signal corresponding to the coroutine from the channel buffer, ending the main thread.
In the above embodiment, the time-out signal may be represented by-1. The preset time period is a sleep time, for example, 50 seconds. After the main thread is ended, an abnormal mark can be returned to inform a user.
In an embodiment, the main thread module is specifically configured to:
and performing an atomic operation of adding 1 to the counter variable by using a method in the Go language atomic library.
The reason for using the methods in the atomic library for atomic operations is that atomic operations are supported by the underlying hardware and are more efficient if multiple coroutines operate on variables concurrently.
In view of the above embodiments, specific pseudo-code is given below.
In summary, the device provided in the embodiment of the present invention has the following beneficial effects:
1. concurrency: the multitask parallel computing is realized by concurrently establishing a coroutine and setting the size of a channel buffer area as the number of CPU cores;
2. real-time performance: and data transmission between the main thread and the coroutine is realized by utilizing the channel, so that the main thread can obtain the calculation result of the coroutine in real time and carry out merging calculation.
3. And (3) robustness: and the overtime processing mechanism is arranged, so that the main thread cannot be locked when the processing time is too long due to the exception of the coroutine.
The embodiment of the invention also provides a multi-task parallel processing method based on the Go language, the principle of which is similar to that of a multi-task parallel processing device based on the Go language, and the description is omitted here.
Fig. 3 is a flowchart of a multi-task parallel processing method based on Go language in the embodiment of the present invention, as shown in fig. 3, including:
In one embodiment, the size of the channel buffer is the number of CPU cores.
In an embodiment, the method further comprises:
initializing a counter variable by using a main thread; after a service processing result of one coroutine is read from a channel buffer area, adding 1 to the counter variable; and judging whether the counter variable is consistent with the coroutine total number or not, if so, outputting a summary result, and if not, continuing to wait for reading a service processing result from the channel buffer area.
In an embodiment, the method further comprises:
for each coroutine, after the coroutine is established, starting an exception handling subprocess, and writing an overtime signal corresponding to the coroutine into a channel after the exception handling subprocess has a preset time length;
and the main thread is utilized to read the overtime signal corresponding to the coroutine from the channel buffer area, and then the main thread is ended.
In one embodiment, the adding 1 operation to the counter variable comprises: and performing an atomic operation of adding 1 to the counter variable by using a method in the Go language atomic library.
A detailed flowchart is given below to explain a detailed process of the Go language-based multitask parallel processing method, and fig. 4 is a detailed flowchart of the Go language-based multitask parallel processing method in the embodiment of the present invention, which includes:
and step 406, judging whether the counter variable is consistent with the coroutine total number by using the main thread, outputting a summary result if the counter variable is consistent with the coroutine total number, and continuously waiting for reading a service processing result from the channel buffer area if the counter variable is inconsistent with the coroutine total number.
In summary, the method provided in the embodiment of the present invention has the following beneficial effects:
1. concurrency: the multitask parallel computing is realized by concurrently establishing a coroutine and setting the size of a channel buffer area as the number of CPU cores;
2. real-time performance: and data transmission between the main thread and the coroutine is realized by utilizing the channel, so that the main thread can obtain the calculation result of the coroutine in real time and carry out merging calculation.
3. And (3) robustness: and the overtime processing mechanism is arranged, so that the main thread cannot be locked when the processing time is too long due to the exception of the coroutine.
An embodiment of the present invention further provides a computer device, and fig. 5 is a schematic diagram of the computer device in the embodiment of the present invention, where the computer device is capable of implementing all steps in the multi-task parallel processing method based on the Go language in the embodiment, and the computer device specifically includes the following contents:
a processor (processor)501, a memory (memory)502, a communication Interface (Communications Interface)503, and a communication bus 504;
the processor 501, the memory 502 and the communication interface 503 complete mutual communication through the communication bus 504; the communication interface 503 is used for implementing information transmission between related devices such as server-side devices, detection devices, and user-side devices;
the processor 501 is used to call the computer program in the memory 502, and when the processor executes the computer program, the processor implements all the steps in the Go language-based multitask parallel processing method in the above embodiment.
An embodiment of the present invention further provides a computer-readable storage medium, which is capable of implementing all steps of the Go language-based multitask parallel processing method in the above-mentioned embodiment, wherein the computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the computer program implements all steps of the Go language-based multitask parallel processing method in the above-mentioned embodiment.
As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
The above-mentioned embodiments are intended to illustrate the objects, technical solutions and advantages of the present invention in further detail, and it should be understood that the above-mentioned embodiments are only exemplary embodiments of the present invention, and are not intended to limit the scope of the present invention, and any modifications, equivalent substitutions, improvements and the like made within the spirit and principle of the present invention should be included in the scope of the present invention.
Claims (12)
1. A multi-task parallel processing apparatus based on Go language, comprising:
the main thread module is used for initializing a channel buffer area; concurrently establishing a plurality of coroutines, and transmitting the channel buffer area as a parameter to the plurality of coroutines, wherein the main thread is used for executing a father task, and each coroutine is used for executing each subtask; reading a channel buffer area, obtaining a coroutine service processing result, executing a main thread service logic, and obtaining a summary result;
and the protocol module is used for executing the service logic of each protocol after each protocol is established and writing the service processing result of each protocol into the channel buffer area.
2. The Go language-based multitasking parallel processing apparatus according to claim 1, wherein a size of said channel buffer is a CPU core number.
3. The Go language-based multitasking parallel processing apparatus according to claim 1, wherein the main thread module is further for:
initializing a counter variable; after a service processing result of one coroutine is read from a channel buffer area, adding 1 to the counter variable; and judging whether the counter variable is consistent with the coroutine total number or not, if so, outputting a summary result, and if not, continuing to wait for reading a service processing result from the channel buffer area.
4. The Go language-based multitasking parallel processing device according to claim 3, characterized in that the coroutine module is further for:
for each coroutine, after the coroutine is established, starting an exception handling subprogram, and after the exception handling subprogram is in a preset time length, writing an overtime signal corresponding to the coroutine into a channel
And (3) recovering: has been changed;
the main thread module is further configured to: and after reading the overtime signal corresponding to the coroutine from the channel buffer, ending the main thread.
5. The Go language-based multitask parallel processing device according to claim 3 or 4, characterized in that the main thread module is specifically configured to:
and performing an atomic operation of adding 1 to the counter variable by using a method in the Go language atomic library.
6. A multi-task parallel processing method based on Go language is characterized by comprising the following steps:
initializing a channel buffer area by using a main thread, and declaring the data type transmitted by the channel buffer area; concurrently establishing a plurality of coroutines, and transmitting the channel buffer area as a parameter to the plurality of coroutines, wherein the main thread is used for executing a father task, and each coroutine is used for executing each subtask;
executing the service logic of each coroutine and writing the service processing result of each coroutine into a channel buffer area;
and reading the channel buffer area by using the main thread, obtaining a service processing result of the coroutine, executing the service logic of the main thread, and obtaining a summary result.
7. The Go language-based multitasking parallel processing method according to claim 6, wherein a size of said channel buffer is a CPU core number.
8. The Go language-based multitask parallel processing method according to claim 6, characterized by further comprising:
initializing a counter variable by using a main thread; after a service processing result of one coroutine is read from a channel buffer area, adding 1 to the counter variable; and judging whether the counter variable is consistent with the coroutine total number or not, if so, outputting a summary result, and if not, continuing to wait for reading a service processing result from the channel buffer area.
9. The Go language-based multitask parallel processing method according to claim 8, characterized by further comprising:
for each coroutine, after the coroutine is established, starting an exception handling subprocess, and writing an overtime signal corresponding to the coroutine into a channel after the exception handling subprocess has a preset time length;
and the main thread is utilized to read the overtime signal corresponding to the coroutine from the channel buffer area, and then the main thread is ended.
10. The Go language-based multitask parallel processing method according to claim 8 or 9, wherein the adding 1 operation to the counter variable includes: and performing an atomic operation of adding 1 to the counter variable by using a method in the Go language atomic library.
11. A computer device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the processor implements the method of any of claims 6 to 10 when executing the computer program.
12. A computer-readable storage medium, characterized in that the computer-readable storage medium stores a computer program for executing the method of any one of claims 6 to 10.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110851044.5A CN113485840A (en) | 2021-07-27 | 2021-07-27 | Multi-task parallel processing device and method based on Go language |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110851044.5A CN113485840A (en) | 2021-07-27 | 2021-07-27 | Multi-task parallel processing device and method based on Go language |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN113485840A true CN113485840A (en) | 2021-10-08 |
Family
ID=77944142
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110851044.5A Pending CN113485840A (en) | 2021-07-27 | 2021-07-27 | Multi-task parallel processing device and method based on Go language |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113485840A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115720238A (en) * | 2022-09-01 | 2023-02-28 | 西安电子科技大学 | Block chain request processing system and method supporting high concurrency |
| CN117032844A (en) * | 2023-10-07 | 2023-11-10 | 北京集度科技有限公司 | Cooperative link tracking device and method and intelligent vehicle |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20160299791A1 (en) * | 2014-01-14 | 2016-10-13 | Tencent Technology (Shenzhen) Company Limited | Method And Apparatus For Processing Computational Task |
| CN111078323A (en) * | 2019-10-12 | 2020-04-28 | 平安科技（深圳）有限公司 | Coroutine-based data processing method and device, computer equipment and storage medium |
| CN111488255A (en) * | 2020-03-27 | 2020-08-04 | 深圳壹账通智能科技有限公司 | Multithreading concurrent monitoring method, device, equipment and storage medium |
-
2021
- 2021-07-27 CN CN202110851044.5A patent/CN113485840A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20160299791A1 (en) * | 2014-01-14 | 2016-10-13 | Tencent Technology (Shenzhen) Company Limited | Method And Apparatus For Processing Computational Task |
| CN111078323A (en) * | 2019-10-12 | 2020-04-28 | 平安科技（深圳）有限公司 | Coroutine-based data processing method and device, computer equipment and storage medium |
| CN111488255A (en) * | 2020-03-27 | 2020-08-04 | 深圳壹账通智能科技有限公司 | Multithreading concurrent monitoring method, device, equipment and storage medium |
Non-Patent Citations (2)
| Title |
|---|
| TIANYAMOON: "换个语言学一下Golang（10）——并行计算", HTTPS://WWW.CNBLOGS.COM/TIANYAMOON/P/11096970.HTML, pages 1 - 8 * |
| YANKAY: "Go-简洁的并发", HTTP://YANKAY.COM/GO-CLEAR-CONCURRENY/, pages 5 - 6 * |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115720238A (en) * | 2022-09-01 | 2023-02-28 | 西安电子科技大学 | Block chain request processing system and method supporting high concurrency |
| CN115720238B (en) * | 2022-09-01 | 2024-04-02 | 西安电子科技大学 | System and method for processing block chain request supporting high concurrency |
| CN117032844A (en) * | 2023-10-07 | 2023-11-10 | 北京集度科技有限公司 | Cooperative link tracking device and method and intelligent vehicle |
| CN117032844B (en) * | 2023-10-07 | 2024-01-09 | 北京集度科技有限公司 | Cooperative link tracking device and method and intelligent vehicle |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110806923B (en) | Parallel processing method and device for block chain tasks, electronic equipment and medium | |
| JP5898188B2 (en) | Dynamic loading of graph-based calculations | |
| CN113535367B (en) | Task scheduling method and related device | |
| US10884822B2 (en) | Deterministic parallelization through atomic task computation | |
| US20090260011A1 (en) | Command line transactions | |
| US20080313502A1 (en) | Systems, methods and computer products for trace capability per work unit | |
| US20140053157A1 (en) | Asynchronous execution flow | |
| JP2009532754A (en) | Abstract execution model for continuation-based meta-runtime | |
| CN113485840A (en) | Multi-task parallel processing device and method based on Go language | |
| WO2019047441A1 (en) | Communication optimization method and system | |
| US8407713B2 (en) | Infrastructure of data summarization including light programs and helper steps | |
| US10496423B2 (en) | Method for opening up data and functions of terminal application based on reconstruction technology | |
| US8356300B2 (en) | Multi-threaded processes for opening and saving documents | |
| US8918767B2 (en) | Pattern-based compilation of asynchronous consumption | |
| CN107958414B (en) | Method and system for eliminating long transactions of CICS (common integrated circuit chip) system | |
| US8572585B2 (en) | Using compiler-generated tasks to represent programming elements | |
| JP5678347B2 (en) | IT system configuration method, computer program thereof, and IT system | |
| CN113835904A (en) | Remote procedure call control method, device, equipment and storage medium | |
| CN114327404A (en) | File processing method and device, electronic equipment and computer readable medium | |
| US10901807B2 (en) | Computer system with concurrency for multithreaded applications | |
| US9201688B2 (en) | Configuration of asynchronous message processing in dataflow networks | |
| US7908375B2 (en) | Transparently externalizing plug-in computation to cluster | |
| CN111857538A (en) | Data processing method, device and storage medium | |
| CN108604192B (en) | System, method, and medium for performing one or more tasks while waiting for an event to be recorded | |
| KR20220002056A (en) | Distributed storage method and device, electronic apparatus, computer-readable medium and computer program product |
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 |