Software construction method, device, computer equipment and storage medium

By executing construction sub-tasks through asynchronous concurrent threads, the problem of time-consuming construction phase in traditional software continuous integration is solved, and the efficiency of continuous integration and task success rate is improved.

CN113760296BActive Publication Date: 2024-11-19SHANGHAI SHUHE INFORMATION TECH CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202110885219.4
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Filing Date
2021-08-03
Publication Date
2024-11-19
Estimated Expiration
2041-08-03

AI Technical Summary

Technical Problem

During the continuous integration of traditional software, the task processing process in the construction stage takes a long time and is inefficient, especially when the software code is large and the construction tasks are large, resulting in low continuous integration efficiency.

Method used

The asynchronous concurrent threads are used to execute construction sub-tasks, breaking the traditional series-type synchronous execution method, and the construction sub-tasks are isolated from each other and do not depend on each other, and shortening the time of the construction phase tasks through asynchronous concurrent execution.

Benefits of technology

It improves the efficiency of continuous software integration, shortens the execution time of tasks in the construction stage, and improves the success rate of task execution.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN113760296B_ABST
    Figure CN113760296B_ABST
Patent Text Reader

Abstract

The present application relates to a software construction method, device, computer equipment and storage medium. The method comprises: obtaining a total construction task, which is a task integrated into the continuous integration pipeline of the software system, and the total construction task includes at least one construction sub-task; respectively allocating corresponding asynchronous concurrent threads to each construction sub-task in the total construction task; each asynchronous concurrent thread respectively reads an executable file, and respectively executes a corresponding construction sub-task based on the executable file, and the executable file is a computer-readable file on which the total construction task depends. The use of this method can improve the efficiency of software continuous integration.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The present application relates to the field of computer software technology, and in particular to a software construction method, apparatus, computer equipment and storage medium. Background Art

[0002] With the development of computer software technology, continuous integration (CI) technology has emerged. Continuous integration is a software development practice that aims to deliver high-quality software frequently and efficiently. For software that needs to be updated multiple times a day, each integration needs to go through a continuous process of compilation, construction, automated testing, etc., so as to find integration errors as early as possible.

[0003] However, in the traditional software continuous integration process, multiple different tasks that convert source code into releasable products are usually connected in series into a continuous integration "pipeline". After the successful completion of a stage of tasks, the next stage of tasks in the pipeline will be started. Each task is connected in series to form a standardized task execution pipeline. However, the processing of serial synchronous tasks is time-consuming, especially in the software build stage in the continuous integration pipeline. The system consumes a lot of time and computing resources in the process of processing the serial tasks in the build stage. When the software code volume is large and the build tasks are large, the software continuous integration takes a long time and is inefficient. Summary of the invention

[0004] Based on this, it is necessary to provide a software construction method, device, computer equipment and storage medium that can improve the continuous integration efficiency of software systems in response to the above technical problems.

[0005] A software construction method, the method comprising: obtaining a total construction task, the total construction task being a task integrated into a continuous integration pipeline of a software system, the total construction task comprising at least one construction sub-task; respectively allocating corresponding asynchronous concurrent threads to each construction sub-task in the total construction task; each asynchronous concurrent thread respectively reads an executable file, and respectively executes a corresponding construction sub-task based on the executable file, the executable file being a computer-readable file on which the total construction task depends.

[0006] In one embodiment, the construction sub-task is at least one of scanning software source code, generating software version information, generating code document information, processing resource files, and generating software quality data.

[0007] In one embodiment, the method further includes: when detecting that the source code of the software system has changed, obtaining the changed source code; compiling the changed source code to generate a computer-readable binary file; and using the binary file as an executable file.

[0008] In one embodiment, the method further includes: collecting execution result data of the corresponding construction sub-tasks executed by each asynchronous concurrent thread, and performing automated testing on the software system according to each execution result data.

[0009] In one embodiment, the method further includes: obtaining construction requirement information of the software system; determining construction sub-tasks that need to be executed according to the construction requirement information; and configuring the overall construction task according to the determined construction sub-tasks.

[0010] In one embodiment, the method further includes: receiving specified task configuration information; and configuring and constructing the overall task according to the task configuration information.

[0011] In one embodiment, each asynchronous concurrent thread reads the executable file respectively, including: each asynchronous concurrent thread parses the corresponding construction sub-task respectively to obtain storage path information, and reads the executable file according to the storage path information.

[0012] A software construction device, the device comprising:

[0013] A build task acquisition module is used to acquire a total build task, where the total build task is a task integrated into a continuous integration pipeline of a software system, and the total build task includes at least one build sub-task;

[0014] An asynchronous thread allocation module is used to allocate corresponding asynchronous concurrent threads to each construction task in the overall construction task;

[0015] The asynchronous thread execution module is used to control each asynchronous concurrent thread to read the executable file respectively, and execute the corresponding construction sub-task based on the executable file respectively. The executable file is a computer-readable file that the construction overall task depends on. A computer device includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the steps of the above-mentioned software component method are implemented.

[0016] A computer-readable storage medium stores a computer program, which implements the steps of the above-mentioned software component method when executed by a processor.

[0017] The above-mentioned software construction method, device, computer equipment and storage medium obtain the total construction task integrated into the continuous integration pipeline, and call the asynchronous concurrent thread to asynchronously execute the various construction sub-tasks in the total construction task in an asynchronous execution mode. On the one hand, it breaks the serial synchronous execution mode in the traditional continuous integration pipeline, inserts the asynchronously executed total construction task in the construction phase of the software, and splits the tasks of the construction phase from other synchronous tasks in the continuous integration pipeline, so that the tasks of the construction phase can be flexibly configured. On the other hand, due to the use of asynchronous concurrent execution, the various construction sub-tasks are isolated from each other and do not depend on each other. Therefore, the execution time of the construction phase tasks can be shortened and the success rate of task execution can be improved, thereby improving the efficiency of continuous integration of software. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] Figure 1 A flowchart of a software construction method in one embodiment;

[0019] Figure 2 A flowchart of a software construction method in an application example;

[0020] Figure 3 A schematic diagram of a continuous integration pipeline in an embodiment of the software construction method of the present solution;

[0021] Figure 4 A structural block diagram of a software building device in one embodiment;

[0022] Figure 5 FIG. 4 is a diagram showing the internal structure of a computer device in one embodiment. DETAILED DESCRIPTION

[0023] In order to make the purpose, technical solution and advantages of the present application more clearly understood, the present application is further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application and are not used to limit the present application.

[0024] The software construction method provided in the present application can be applied to a server. Specifically, the server obtains a total construction task, obtains the total construction task, the total construction task is a task integrated into the continuous integration pipeline of the software system, and the total construction task includes at least one construction sub-task; corresponding asynchronous concurrent threads are respectively assigned to each construction sub-task in the total construction task; each asynchronous concurrent thread reads an executable file respectively, and executes the corresponding construction sub-task based on the executable file respectively, and the executable file is a computer-readable file on which the total construction task depends. Among them, the server can be implemented by a separate server or a server cluster.

[0025] In one embodiment, Figure 1As shown, a software construction method is provided, which may include the following steps:

[0026] Step S102: obtaining a total build task, where the total build task is a task integrated into a continuous integration pipeline of a software system, and the total build task includes at least one build sub-task.

[0027] Among them, the continuous integration pipeline, that is, the continuous integration pipeline, is an assembly line for automated task execution during the continuous integration and delivery of software. Traditional continuous integration pipelines are highly customized and can only perform synchronous execution of serial tasks for a certain software system to complete pipeline standard delivery. They cannot arbitrarily access, integrate or modify tasks in the build phase. The total build task refers to the task of the build phase that can be integrated into the continuous integration pipeline. The total build task can be flexibly configured in advance according to needs, and the configured total build task can be further encapsulated into a component. The total build task can include at least one pre-configured build sub-task.

[0028] Specifically, the server obtains a total build task that is integrated into the continuous integration pipeline in the form of a plug-in, component, etc. Preferably, the component encapsulating the total build task is not limited to the software code type and plug-in type, and can be non-invasively integrated into the continuous integration pipeline. The user can configure the total build task, which can include at least one pre-configured build sub-task. The number, type, combination form, etc. of the build sub-tasks are not limited, and the configuration can be flexibly modified, adjusted, increased or decreased according to the different needs of different software systems.

[0029] Step S104: assigning corresponding asynchronous concurrent threads to each construction task in the overall construction task.

[0030] Specifically, a corresponding number of asynchronous concurrent threads may be called according to the number of build sub-tasks configured in the overall build task, and one asynchronous concurrent thread may execute one build sub-task accordingly.

[0031] Step S106: Each asynchronous concurrent thread reads an executable file respectively, and executes a corresponding construction sub-task based on the executable file respectively. The executable file is a computer-readable file that the overall construction task depends on.

[0032] Specifically, after each asynchronous concurrent thread is called, it executes the corresponding build sub-task respectively, and reads the executable files that the overall build task depends on according to the information carried by the corresponding build sub-task. That is, different build sub-tasks can read the same executable file independently and without affecting each other, and realize asynchronous concurrent execution based on the same executable file.

[0033] The above-mentioned software construction method obtains the total construction task integrated into the continuous integration pipeline, and calls the asynchronous concurrent thread to asynchronously execute the various construction sub-tasks in the total construction task in an asynchronous execution mode. On the one hand, it breaks the serial synchronous execution mode in the traditional continuous integration pipeline, inserts the asynchronously executed total construction task in the software construction phase, and splits the tasks of the construction phase from other synchronous tasks in the continuous integration pipeline, so that the tasks of the construction phase can be flexibly configured. On the other hand, due to the use of asynchronous concurrent execution, the various construction sub-tasks are isolated and independent of each other. Therefore, the execution time of the construction phase tasks can be shortened and the success rate of task execution can be improved, thereby improving the efficiency of software continuous integration.

[0034] In one embodiment, the construction sub-task is at least one of scanning software source code, generating software version information, generating code document information, processing resource files, and generating software quality data.

[0035] In this embodiment, the construction subtask refers to a task that can be performed in the construction phase of the continuous integration pipeline. Different software systems have different tasks to be performed in the construction phase. For example, some software systems as a whole do not need to provide external services, so the task of generating code document information can be omitted. Therefore, the type, quantity and combination of construction subtasks can be flexibly adjusted according to demand to improve the adaptability of continuous integration.

[0036] In one embodiment, the method further includes: when detecting that the source code of the software system has changed, obtaining the changed source code, compiling the changed source code, generating a computer-readable binary file, and using the binary file as an executable file.

[0037] In this embodiment, whenever a change is detected in the source code of the software system, the changed source code can be pulled from the code library, and the source code can be compiled to generate a computer-readable binary executable file.

[0038] Furthermore, the compiled binary files can also be stored. Since the overall build task is separated from other synchronous tasks such as detection and compilation in the pipeline, even if the build task is modified, adjusted, increased or decreased, as long as there are no other changes to the source code, there is no need to recompile the file. The tasks of the build phase can be executed asynchronously based on the stored compiled executable files, thereby improving the efficiency of software continuous integration.

[0039] In one embodiment, the method further includes: collecting execution result data of the corresponding construction sub-tasks executed by each asynchronous concurrent thread, and performing automated testing on the software system according to each execution result data.

[0040] In this embodiment, since each build sub-task is independent of each other, subsequent automated testing will not be unable to be implemented due to the failure of one of the build tasks. Therefore, by collecting the execution results of each build sub-task separately and performing automated testing based on the execution result data, the efficiency of automated testing in the software continuous integration process can be improved.

[0041] In one embodiment, the method further includes: obtaining construction requirement information of the software system; determining construction sub-tasks that need to be executed according to the construction requirement information; and configuring the overall construction task according to the determined construction sub-tasks.

[0042] In this embodiment, different build sub-tasks can be screened according to the build requirements of different software systems, and the screened build sub-tasks can be combined and configured to generate a total build task, and then the combined and configured total build task can be integrated into the build stage in the continuous integration pipeline of the software system.

[0043] In one embodiment, the method further includes: receiving specified task configuration information, and configuring and constructing the overall task according to the task configuration information.

[0044] In this embodiment, the user can arbitrarily select or specify task configuration information through the terminal device. The task configuration information is used to characterize the configuration scheme or configuration rules of the overall build task. The terminal device receives the task configuration information specified by the user, configures the overall build task according to the task configuration information, and integrates the configured overall build task into the continuous integration pipeline, so that when the software build of the continuous integration pipeline is started, the server can obtain the configured overall build task.

[0045] In one embodiment, each asynchronous concurrent thread reads the executable file respectively, including: each asynchronous concurrent thread parses the corresponding construction sub-task respectively to obtain storage path information, and reads the executable file according to the storage path information.

[0046] In a traditional continuous integration pipeline, when executing tasks in the build phase, each build task is queued in a preset order to read the same executable file. Once the build tasks in the build phase are adjusted, the synchronous execution is interrupted, and it is necessary to repeat the source code detection, compilation and other stages from the beginning of the continuous integration pipeline before entering the build phase again.

[0047] In this embodiment, since each construction task includes path information, the compiled binary executable file that the construction task depends on can be read separately according to the path information. That is, the construction phase is based on the construction task as the execution, configuration or adjustment dimension, and different construction tasks can read the same executable file independently and without affecting each other, and realize asynchronous concurrent execution based on the same executable file. Even if some individual construction tasks are adjusted, changed, increased or decreased, or errors occur, other construction tasks can still read the executable file through the path information and execute them separately, without the need to start over as a whole.

[0048] Next, the software component method involved in the present application is further described in detail in conjunction with an embodiment in a practical application. Figure 2 As shown, Figure 2 The flowchart of the software construction method in an application example may include the following steps:

[0049] S201: The user configures a construction task to be executed asynchronously, and generates an asynchronous construction component (total construction task).

[0050] S202: Integrate the asynchronous build component in a continuous integration pipeline. Figure 3 shown.

[0051] S203: In the continuous integration pipeline, compile the source code and generate binary files.

[0052] S204: Acquire multiple build tasks (build sub-tasks) configured in the asynchronous build component.

[0053] S205: Start an asynchronous process.

[0054] S206: Each asynchronous thread executes the construction task asynchronously and concurrently.

[0055] S207: Collect execution result data.

[0056] The software construction method involved in this application has at least the following advantages:

[0057] 1. The software build process supports asynchronous and parallel execution of various build tasks. The traditional continuous integration pipeline has a high degree of integration, and the build tasks cannot flexibly meet the build requirements.

[0058] 2. Asynchronous build components do not limit software code types and plug-in types, and asynchronous build components can be integrated non-invasively in the continuous integration pipeline.

[0059] 3. Asynchronous build tasks can be flexibly configured according to needs. Build tasks are pluggable, and adding new build tasks will not affect build efficiency. In addition, asynchronous parallel builds can isolate each task from each other, so that each build task does not affect each other, and task failure will not affect other build tasks.

[0060] It should be understood that although Figure 1-2 The steps in the flowchart are shown in sequence as indicated by the arrows, but these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified in this document, there is no strict order restriction for the execution of these steps, and these steps can be executed in other orders. Moreover, Figure 1-2 At least part of the steps may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily executed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequential, but can be executed in turn or alternately with other steps or at least part of the sub-steps or stages of other steps.

[0061] In one embodiment, Figure 4 As shown, a software construction device is provided, including: a construction task acquisition module 410, an asynchronous thread allocation module 420 and an asynchronous thread execution module 430, wherein:

[0062] A build task acquisition module 410 is used to acquire a total build task, where the total build task is a task integrated into a continuous integration pipeline of a software system, and the total build task includes at least one build sub-task;

[0063] An asynchronous thread allocation module 420 is used to allocate corresponding asynchronous concurrent threads to each construction task in the overall construction task;

[0064] The asynchronous thread execution module 430 is used to control each asynchronous concurrent thread to read an executable file respectively, and execute the corresponding construction sub-task based on the executable file respectively. The executable file is a computer-readable file that the overall construction task depends on.

[0065] In one embodiment, the device also includes an executable file compilation module 400, which is used to obtain the changed source code when it is detected that the source code of the software system has changed; compile the changed source code to generate a computer-readable binary file; and use the binary file as an executable file.

[0066] In one embodiment, the device further includes an automated testing module 440, which collects execution result data of the corresponding construction sub-tasks executed by each asynchronous concurrent thread, and performs automated testing on the software system according to each execution result data.

[0067] In one embodiment, the build task acquisition module 410 is further used to acquire build requirement information of the software system; determine the build sub-tasks that need to be executed according to the build requirement information; and configure the overall build task according to the determined build sub-tasks.

[0068] In one embodiment, the construction task acquisition module 410 is further used to receive specified task configuration information; and configure the overall construction task according to the task configuration information.

[0069] In one embodiment, the asynchronous thread execution module 430 controls each asynchronous concurrent thread to parse the corresponding construction sub-task respectively, obtains the storage path information, and reads the executable file according to the storage path information.

[0070] For the specific definition of the software construction device, please refer to the definition of the software construction method above, which will not be repeated here. Each module in the above-mentioned software construction device can be implemented in whole or in part by software, hardware and a combination thereof. The above-mentioned modules can be embedded in or independent of the processor in the computer device in the form of hardware, or can be stored in the memory in the computer device in the form of software, so that the processor can call and execute the operations corresponding to the above modules.

[0071] In one embodiment, a computer device is provided. The computer device may be a server, and its internal structure diagram may be as follows: Figure 5 As shown. The computer device includes a processor, a memory, and a network interface connected through a system bus. Among them, the processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program, and a database. The internal memory provides an environment for the operation of the operating system and the computer program in the non-volatile storage medium. The network interface of the computer device is used to communicate with an external terminal through a network connection. When the computer program is executed by the processor, a software construction method is implemented.

[0072] Those skilled in the art will understand that Figure 5 The structure shown in the figure is only a block diagram of a part of the structure related to the solution of the present application, and does not constitute a limitation on the computer device to which the solution of the present application is applied. The specific computer device may include more or fewer components than those shown in the figure, or combine certain components, or have a different arrangement of components.

[0073] In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the following steps are implemented: obtaining a general build task, which is a task integrated into a continuous integration pipeline of a software system, and the general build task includes at least one build sub-task; respectively allocating corresponding asynchronous concurrent threads to each build sub-task in the general build task; respectively reading an executable file, and respectively executing a corresponding build sub-task based on the executable file, wherein the executable file is a computer-readable file on which the general build task depends.

[0074] In one embodiment, when executing a computer program, the processor further implements the following steps: when detecting that the source code of the software system has changed, obtaining the changed source code; compiling the changed source code to generate a computer-readable binary file; and using the binary file as an executable file.

[0075] In one embodiment, when the processor executes the computer program, the following steps are also implemented: collecting execution result data of the corresponding construction sub-tasks executed by each asynchronous concurrent thread, and performing automatic testing on the software system according to each execution result data.

[0076] In one embodiment, when the processor executes the computer program, the following steps are also implemented: obtaining construction requirement information of the software system; determining construction sub-tasks that need to be executed according to the construction requirement information; and configuring the overall construction task according to the determined construction sub-tasks.

[0077] In one embodiment, when the processor executes the computer program, the following steps are further implemented: receiving specified task configuration information; and configuring and constructing the overall task according to the task configuration information.

[0078] In one embodiment, when the processor executes a computer program to implement each asynchronous concurrent thread to read an executable file respectively, the following steps are specifically implemented: each asynchronous concurrent thread respectively parses the corresponding construction sub-task, obtains storage path information, and reads the executable file according to the storage path information.

[0079] In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored. When the computer program is executed by a processor, the following steps are implemented: obtaining a total build task, the total build task is a task integrated into a continuous integration pipeline of a software system, and the total build task includes at least one build sub-task; respectively allocating corresponding asynchronous concurrent threads to each build sub-task in the total build task; each asynchronous concurrent thread respectively reads an executable file, and respectively executes a corresponding build sub-task based on the executable file, the executable file being a computer-readable file on which the total build task depends.

[0080] In one embodiment, when the computer program is executed by the processor, the following steps are also implemented: when a change is detected in the source code of the software system, the changed source code is obtained; the changed source code is compiled to generate a computer-readable binary file; and the binary file is used as an executable file.

[0081] In one embodiment, when the computer program is executed by the processor, the following steps are also implemented: collecting execution result data of the corresponding construction sub-tasks executed by each asynchronous concurrent thread, and performing automatic testing on the software system according to each execution result data.

[0082] In one embodiment, when the computer program is executed by the processor, the following steps are also implemented: obtaining construction requirement information of the software system; determining the construction sub-tasks that need to be executed according to the construction requirement information; and configuring the overall construction task according to the determined construction sub-tasks.

[0083] In one embodiment, when the computer program is executed by the processor, the following steps are also implemented: receiving specified task configuration information; and configuring and constructing the overall task according to the task configuration information.

[0084] In one embodiment, when the computer program is executed by the processor to implement each asynchronous concurrent thread to read the executable file respectively, the following steps are specifically implemented: each asynchronous concurrent thread respectively parses the corresponding construction task, obtains the storage path information, and reads the executable file according to the storage path information. In one embodiment, when the computer program is executed by the processor, the following steps are also implemented:

[0085] Those skilled in the art can understand that all or part of the processes in the above-mentioned embodiment methods can be completed by instructing the relevant hardware through a computer program, and the computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, any reference to memory, storage, database or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM) or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. As an illustration and not limitation, RAM is available in many forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link (Synchlink) DRAM (SLDRAM), memory bus (Rambus) direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM).

[0086] The technical features of the above embodiments may be arbitrarily combined. To make the description concise, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0087] The above-mentioned embodiments only express several implementation methods of the present application, and the descriptions thereof are relatively specific and detailed, but they cannot be understood as limiting the scope of the invention patent. It should be pointed out that, for a person of ordinary skill in the art, several variations and improvements can be made without departing from the concept of the present application, and these all belong to the protection scope of the present application. Therefore, the protection scope of the patent of the present application shall be subject to the attached claims.

Claims

1. A software construction method, the method comprising: Receive the specified task configuration information, and configure and build the overall task according to the task configuration information; Or, different build sub-tasks are screened according to the build requirements of different software systems, the screened build sub-tasks are combined and configured to generate a total build task, and then the combined and configured total build task including the asynchronously executed build sub-tasks is inserted into the build stage of the continuous integration pipeline of the software system in the form of a plug-in or component; Obtaining a total build task, where the total build task is a task inserted into a build phase of a continuous integration pipeline of a software system, and the total build task includes at least one build sub-task; Assign corresponding asynchronous concurrent threads to each construction task in the overall construction task respectively; Each of the asynchronous concurrent threads parses the corresponding construction sub-task respectively, obtains storage path information, reads the executable file according to the storage path information, and executes the corresponding construction sub-task based on the executable file respectively. The executable file is a computer-readable file on which the overall construction task depends.

2. The method according to claim 1, characterized in that The construction sub-task is at least one of the tasks of scanning software source code, generating software version information, generating code document information, processing resource files, and generating software quality data.

3. The method according to claim 1, characterized in that The method further comprises: When detecting that the source code of the software system has changed, obtaining the changed source code; Compile the changed source code to generate a computer-readable binary file; The binary file is used as the executable file.

4. The method according to claim 1, characterized in that: The method further comprises: The execution result data of the corresponding construction sub-task executed by each of the asynchronous concurrent threads is collected, and the software system is automatically tested according to each of the execution result data.

5. A software construction device, characterized in that: The device comprises: A build task acquisition module is used to receive specified task configuration information and configure a total build task according to the task configuration information; or, screen different build sub-tasks according to the build requirements of different software systems, combine and configure the screened build sub-tasks to generate a total build task, and then insert the combined and configured total build task including asynchronously executed build sub-tasks into the build phase of the continuous integration pipeline of the software system in the form of a plug-in or component to obtain the total build task, wherein the total build task is a task inserted into the build phase of the continuous integration pipeline of the software system, and the total build task includes at least one build sub-task; An asynchronous thread allocation module is used to allocate corresponding asynchronous concurrent threads to each construction task in the overall construction task; An asynchronous thread execution module is used to control each of the asynchronous concurrent threads to parse the corresponding construction sub-tasks respectively, obtain storage path information, read executable files according to the storage path information, and execute corresponding construction sub-tasks based on the executable files respectively. The executable files are computer-readable files on which the overall construction task depends.

6. A computer device comprising a memory, a processor and a computer program stored in the memory and executable on the processor, characterized in that: When the processor executes the computer program, the steps of the method according to any one of claims 1 to 4 are implemented.

7. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 4 are implemented.