CN106445617B - Android-based application cold start optimization method and system - Google Patents
Android-based application cold start optimization method and system Download PDFInfo
- Publication number
- CN106445617B CN106445617B CN201610896161.2A CN201610896161A CN106445617B CN 106445617 B CN106445617 B CN 106445617B CN 201610896161 A CN201610896161 A CN 201610896161A CN 106445617 B CN106445617 B CN 106445617B
- Authority
- CN
- China
- Prior art keywords
- data
- registration interface
- bundle
- application program
- thread pool
- 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.)
- Expired - Fee Related
Links
- 238000000034 method Methods 0.000 title claims abstract description 62
- 238000005457 optimization Methods 0.000 title claims abstract description 12
- 230000008569 process Effects 0.000 claims abstract description 29
- 238000013500 data storage Methods 0.000 claims description 8
- 238000005538 encapsulation Methods 0.000 claims description 7
- 238000012544 monitoring process Methods 0.000 claims description 7
- 238000012858 packaging process Methods 0.000 claims description 2
- 230000004044 response Effects 0.000 abstract description 2
- 238000007493 shaping process Methods 0.000 description 8
- 238000007667 floating Methods 0.000 description 4
- 230000003068 static effect Effects 0.000 description 4
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 239000000284 extract Substances 0.000 description 1
- 238000004806 packaging method and process Methods 0.000 description 1
- 230000000737 periodic effect Effects 0.000 description 1
- 238000003825 pressing 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/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44505—Configuring for program initiating, e.g. using registry, configuration files
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses an Android-based application cold start optimization method and system, wherein the method comprises the following steps: starting an application program; starting a thread pool task, initializing all data in the starting process of the application program through a plurality of sub-threads in parallel, and sending the initialized data to a registration interface of the application program; and the registration interface analyzes the received initialization data and refreshes the registration interface in time. The invention can accelerate the cold start speed of the application program, thereby improving the response speed of the application program and improving the use experience of a user.
Description
Technical Field
The invention relates to a starting technology of an application program in Android, in particular to an application program cold start optimization method and system based on Android.
Background
The starting modes of the application programs in the Android are 2 in total, one is cold starting, and the other is hot starting. Typically, the time for a cold start of an application will be longer than the time for a warm start of an application. Too long a start-up time may greatly affect the user experience. For example, if the start-up time is too long, the time from the start-up to the appearance of the interface will be longer, and the display in this period will be in a white screen state. Too long a start-up time may also result in a long wait time for the user to enter the application, which greatly reduces the user experience.
Disclosure of Invention
The invention aims to provide a method for accelerating cold start of an application program in Android, which can accelerate the cold start speed of the application program, so that the use experience of a user is greatly improved.
In order to achieve the purpose, the invention adopts the technical scheme that:
the method for optimizing the cold start of the application program based on the Android comprises the following steps:
starting an application program;
starting a thread pool task, initializing all data in the starting process of the application program through a plurality of sub-threads in parallel, and sending the initialized data to a registration interface of the application program;
and the registration interface analyzes the received initialization data and refreshes the registration interface in time.
According to the method, after the thread pool task is started, the uninitialized data is replaced by the predefined default data, so that the registration interface is rapidly displayed.
In the method, the thread pool is a fixed-length thread pool, the maximum concurrency number of the sub-threads is set in the fixed-length thread pool, and the exceeding sub-threads wait in the queue.
In the method, if the initialization of the data in a certain sub-thread is completed, the initialized data is packaged in the broadcast message and then sent out.
In the method of the invention, the data encapsulation process is as follows: and storing the initialized data through a data storage tool in the Android system, and calling different storage functions for storing different data.
In the method of the invention, the data storage tool is Bundle, and the data encapsulation process specifically comprises the following steps:
if the data is int data, calling a putInt function in the Bundle to store the int data into the Bundle;
if the String data is String data, a putString function in the Bundle is called (the function is mainly used for storing the character String data) to store the String data into the Bundle.
If the data is long data, calling a put L ong function in the Bundle to store the long data in the Bundle;
if the data is the float data, a putFloat function in the Bundle is called to store the float data in the Bundle.
In the method, the registration interface receives data by monitoring broadcast, analyzes the received data, and calls different functions according to the data type to acquire corresponding data.
In the method of the present invention, the method further comprises the steps of:
and when the registered interface is completely refreshed, closing the thread pool and quickly releasing the resources in the thread pool.
The invention also provides an Android-based application cold start optimization system, which is characterized by comprising the following steps:
the starting module is used for starting the application program;
the thread pool module is used for starting a thread pool task, initializing all data in the starting process of the application program through a plurality of sub-threads in parallel and sending the initialized data to a registration interface of the application program;
and the registration interface module is used for analyzing the received initialization data and refreshing a registration interface.
In the Android-based application cold start optimization system, the registration interface module is further used for replacing uninitialized data with predefined default data after a thread pool task is started so as to quickly display a registration interface.
The invention has the following beneficial effects: the method adopts a thread pool mode to asynchronously initialize data in the cold starting process of any application program of the Android, and sends all initialized data to the interface through the broadcast message after the data initialization is completed, so that the interface is refreshed. The invention can accelerate the cold start speed of the application program, thereby improving the response speed of the application program and improving the use experience of a user.
Further, when the data on the registration interface is not completely initialized, default data is used for replacement, and the registration interface can be preferentially and quickly displayed.
Drawings
The invention will be further described with reference to the accompanying drawings and examples, in which:
FIG. 1 is a flowchart of an Android-based application cold start optimization method according to an embodiment of the present invention;
FIG. 2 is a flowchart illustrating a method for optimizing cold boot of an Android-based application according to another embodiment of the present invention;
FIG. 3 is a flow chart of data encapsulation of the present invention;
FIG. 4 is a flowchart illustrating an optimization method for Android-based application cold boot according to a third embodiment of the present invention;
fig. 5 is a structural diagram of an application cold start optimization system based on Android in the embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, the present invention is described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.
The related nouns are explained as follows:
cold start: when an application is started, the background does not have a process of the application, and the system can recreate a new process to be allocated to the application, wherein the starting mode is cold starting.
And (3) hot start: when an application is started, the background already has the process of the application (for example, the application exits by pressing a back key and a home key, but the process of the application still remains in the background and can enter a task list to be viewed), so in the case of the existing process, the starting starts the application from the existing process, which is called warm starting.
The application cold start of the invention is different from the cold start of the system, the invention only aims at the cold start of a certain application, and the start of the system relates to the start of a plurality of applications. In addition, the cold start of the application program is started multithreading to accelerate the start of the application program, and the cold start of the system is a mode of starting multiprocessing and prohibiting some program from starting to achieve the aim of quick start. The invention mainly aims to improve the cold start speed of the application program and reduce the waiting time of a user during cold start, thereby improving the user experience.
The most time-consuming procedure in the Android application cold start process is the initialization of some start conditions, and the interface display is performed after the initialization is completed. In order to accelerate the starting speed of the application program, the invention adopts a thread pool mode to asynchronously initialize data. And starting a plurality of sub threads through the thread pool in the process of displaying the application program to carry out initialization operation on the program.
In a first embodiment of the present invention, as shown in fig. 1, a method for optimizing cold start of an application based on Android includes the following steps:
s101, starting an application program;
s103, starting a thread pool task, and initializing all data in the starting process of the application program through a plurality of sub-threads in parallel;
s105, sending the initialized data to a registration interface of the application program;
s107, the registration interface analyzes the received initialization data and refreshes the registration interface in time.
In step S101, the corresponding application program can be found through the Android desktop, and the application program icon is clicked, so that the application program is started.
Because a plurality of sub-threads are started to process the initialization of all data and the interface is displayed on the main thread, the display flow of the interface does not need to wait for the completion of the initialization of all the data to display, and the interface can be displayed preferentially. The interface can be displayed more quickly by preferentially displaying the interface, and at this time, part of data on the interface may not be completely initialized at this time, and default data can be used for replacement. In another embodiment of the present invention, as shown in fig. 2, the method for optimizing cold start of an application based on Android includes the following steps:
s101, starting an application program;
s103, starting a thread pool task, and initializing all data in the starting process of the application program through a plurality of sub-threads in parallel;
s104, judging whether the initialization of the sub thread is finished or not, if so, executing the step S105; if not, the step S108 is executed;
s105, sending the initialized data to a registration interface of the application program;
s107, the registration interface analyzes the received initialization data and refreshes the registration interface in time.
And S108, after the thread pool task is started, replacing uninitialized data with predefined default data to quickly display a registration interface.
The thread pool can be various, and the common several modes in the Android system are as follows:
1. newCachedThreadPool: and establishing a cacheable thread pool, if the length of the thread pool exceeds the processing requirement, flexibly recovering idle threads, and if the length of the thread pool is not recoverable, newly establishing a thread.
2. newfixedthreedpool: and a fixed-length thread pool is created, the maximum concurrency number of the threads can be controlled, and the exceeding threads wait in the queue.
3. newschedulthreadpool: and a fixed-length thread pool is created to support timing and periodic task execution.
4. The newSingleThreadExecutor creates a single threaded thread pool which will only use the only working thread to execute the tasks, ensuring that all tasks execute in the specified order (FIFO, <ttttranslation = L "&tttL &ttt/T &tttIFO, priority).
In order to increase the utilization rate of the threads and not influence the system overhead too much, in the preferred embodiment of the invention, a thread manager newFixedThreadPool which creates a function of a fixed-length thread pool is selected, the fixed-length thread pool can control the maximum concurrency number of the threads, and the exceeding threads wait in the queue. The maximum number of tasks of a thread can be set to 3. This enables a maximum of 3 threads to be started simultaneously to perform initialization operations on all data. If there are 5 initialization tasks at the same time, 3 of them are executed first, and the rest are waiting in the queue. When any of the 3 first processes is completed, the 4 th is processed, and so on. The fixed-length thread pool can improve the initial efficiency and simultaneously can not increase the extra overhead caused to the system.
In the above embodiment, if the initialization of the data in a certain sub-thread is completed, the initialized data is encapsulated in the broadcast message and then sent out. The registration interface receives the corresponding broadcast message, extracts and analyzes the required data from the broadcast message, and refreshes the registration interface immediately after acquiring the data. As long as one of the child threads is initialized, the interface can be refreshed in time.
Furthermore, besides encapsulating the initialized data in the broadcast message and sending out, the initialized data can also be sent out through a Handler, an interface and the like.
The data encapsulation process comprises the following steps: and storing the initialized data through a data storage tool in the Android system, and calling different storage functions for storing different data. As shown in fig. 3, the data encapsulation process is as follows:
storing the initialized data through a Bundle (which is a tool for storing data in an Android system), and calling different methods for storing different data.
1. If the data is int (shaping data), a putInt function in the Bundle is called, wherein the function has the main function of storing the shaping data, and the int data is stored in the Bundle.
2. If it is String (String data), we call the putString function in the Bundle (the function is mainly used for storing the String data) to store the String data into the Bundle.
3. If the long shaping data is long, a put L ong function in the Bundle is called, and the function mainly has the function of storing the long shaping data to store the long shaping data into the Bundle.
4. If the data is float (floating point type data), a putFloat function in the Bundle is called (the main function of the function is to store the floating point type data) to store the float data in the Bundle.
It is understood that the initialized data may be stored by other storage tools in the Android system, such as SharedPreferences, sqlite, file, and the like.
In the embodiment of the invention, the data sending process is as follows:
first, data is stored in a broadcast, and a storage process stores the Bundle data in the Intent (storing Bundle data) by calling a putBundle function (storing Bundle data) in the Intent (a tool for sending the broadcast). After the data is stored, the data carrying the Bundle is sent out through a sendBroadcast function. So that the recipient can receive the data.
Preferably, the registration interface receives data by monitoring broadcast, analyzes the received data, and calls different functions according to the data type to obtain corresponding data.
Wherein:
a) registering and listening for broadcast data
The monitoring of the broadcast is mainly divided into 2 types, monitoring static broadcast and monitoring dynamic broadcast. Static broadcasting: static broadcasts are broadcasts that can be received whenever an application starts or not. Dynamic broadcasting: the broadcast receiver can only accept the broadcast if the application is running, only if the application is dynamically registered by the code after it has started. The preferred embodiment of the present invention uses a registered static broadcast to receive data. Thus, the transmitted data can be received under any condition.
b) Parsing broadcast data
The main purpose of broadcast analysis is to analyze data information contained in the broadcast, data is stored in a Bundle in the broadcast sending process, and the analysis process and the data storage obsolescence are opposite, and the method is implemented as follows:
first, get the Bundle object by broadcasting to call getBundle. After the Bundle object is acquired, analyzing the data in the Bundle:
if the data is int (shaping data), a getInt function in the Bundle is called (the function main function is to obtain shaping data) to obtain int data in the Bundle.
If it is String (character String data), calling getString function in the Bundle (the function main function is to obtain character String data) to obtain String data in the Bundle.
If it is long, call get L ong function in Bundle (the main function of this function is to get long shaping data) to get L ong data in Bundle.
If the data is Float (floating point type data), the getFloat function in the Bundle (the main function of the function is to obtain floating point data) is called to obtain the Float data in the Bundle.
All data in the Bundle can be analyzed through the analysis.
c) Refreshing an interface
And when the data is completely analyzed, the acquired data can be used for updating the interface program. At this time, the complete effect of finally loading good data can be displayed on the interface.
And after the interface is completely refreshed, the resources in the thread pool can be quickly released by closing the thread pool. This may reserve more resources for other programs to use. As shown in fig. 4, steps can be added on the basis of the above embodiment:
and S109, after the registered interface is completely refreshed, closing the thread pool, and quickly releasing the resources in the thread pool.
The Android-based application cold start optimization system provided by the embodiment of the invention is mainly used for realizing the method of the embodiment, and as shown in fig. 5, the system comprises a start module, a thread pool module, a data sending module and a registration interface module. Wherein:
the starting module is used for starting the application program;
the thread pool module is used for starting a thread pool task and initializing all data in the starting process of the application program through a plurality of sub-threads in parallel;
the data sending module is used for sending the initialized data to a registration interface of the application program;
and the registration interface module is used for analyzing the received initialization data and refreshing a registration interface.
Preferably, the thread pool is a fixed-length thread pool, which can control the maximum number of concurrent threads, and the exceeded threads wait in the queue.
Preferably, the registration interface module is further configured to replace uninitialized data with predefined default data after the thread pool task is started, so as to quickly display the registration interface.
And if the data in a certain sub-thread is initialized, packaging the initialized data in the broadcast, and then sending out.
The data encapsulation process comprises the following steps: and storing the initialized data through a data storage tool in the Android system, and calling different storage functions for storing different data.
The data storage tool can select a Bundle in an Android system, and the data packaging process specifically comprises the following steps:
if the data is int data, a putInt function in the Bundle is called to store the int data into the Bundle.
If the data is String data, a putString function in the Bundle is called to store the String data into the Bundle.
If the data is long data, calling a put L ong function in the Bundle to store the long data in the Bundle;
if the data is the float data, a putFloat function in the Bundle is called to store the float data in the Bundle.
The registration interface module may receive data by monitoring broadcast, analyze the received data, and call different functions according to the data type to obtain corresponding data.
In another embodiment of the present invention, the thread pool module is further configured to close the thread pool after the registration interface is completely refreshed, and quickly release the resources in the thread pool.
It will be understood that modifications and variations can be made by persons skilled in the art in light of the above teachings and all such modifications and variations are intended to be included within the scope of the invention as defined in the appended claims.
Claims (8)
1. An Android-based application cold start optimization method is characterized by comprising the following steps:
starting an application program;
starting a thread pool task, initializing all data in the starting process of the application program through a plurality of sub-threads in parallel, and sending the initialized data to a registration interface of the application program; after a thread pool task is started, if initialization in a sub thread is completed, sending initialized data to a registration interface of an application program, analyzing the registration interface and refreshing the registration interface in time; otherwise, replacing uninitialized data by predefined default data to preferentially display a registration interface;
and the registration interface analyzes the received initialization data and refreshes the registration interface in time.
2. The method of claim 1, wherein the thread pool is a fixed-length thread pool, wherein a maximum number of concurrencies for sub-threads is set, and wherein excess sub-threads wait in a queue.
3. The method of claim 1, wherein if the initialization of the data in a sub-thread is completed, the initialized data is encapsulated in the broadcast message and then transmitted.
4. The method of claim 3, wherein the data encapsulation process is: and storing the initialized data through a data storage tool in the Android system, and calling different storage functions for storing different data.
5. The method of claim 4, wherein the data storage tool is Bundle, and the data packaging process is specifically:
if the data is int data, calling a putInt function in the Bundle to store the int data into the Bundle;
if the data is String data, calling a putString function in the Bundle to store the String data into the Bundle;
if the data is long data, calling a put L ong function in the Bundle to store the long data in the Bundle;
if the data is the float data, a putFloat function in the Bundle is called to store the float data in the Bundle.
6. The method of claim 1, wherein the registration interface receives data by monitoring broadcast, parses the received data, and calls different functions to obtain corresponding data according to the type of the data.
7. The method according to any of claims 1-6, characterized in that the method further comprises the step of:
and when the registered interface is completely refreshed, closing the thread pool, and quickly releasing the resources in the thread pool.
8. An Android-based application cold start optimization system is characterized by comprising:
the starting module is used for starting the application program;
the thread pool module is used for starting a thread pool task and initializing all data in the starting process of the application program through a plurality of sub-threads in parallel;
the data sending module is used for sending the initialized data to a registration interface of the application program;
the registration interface module is used for sending initialized data to a registration interface of an application program if the initialization in a sub thread is completed after the thread pool task is started, and the registration interface is analyzed and refreshed in time; otherwise, the registration interface is preferentially displayed by replacing uninitialized data with predefined default data, and the received initialized data is analyzed and the registration interface is refreshed.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201610896161.2A CN106445617B (en) | 2016-10-13 | 2016-10-13 | Android-based application cold start optimization method and system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201610896161.2A CN106445617B (en) | 2016-10-13 | 2016-10-13 | Android-based application cold start optimization method and system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN106445617A CN106445617A (en) | 2017-02-22 |
| CN106445617B true CN106445617B (en) | 2020-08-04 |
Family
ID=58173570
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201610896161.2A Expired - Fee Related CN106445617B (en) | 2016-10-13 | 2016-10-13 | Android-based application cold start optimization method and system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN106445617B (en) |
Families Citing this family (10)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107741869A (en) * | 2017-11-20 | 2018-02-27 | 青岛海信移动通信技术股份有限公司 | The startup method, apparatus and terminal device of application program |
| CN109117203A (en) * | 2018-07-13 | 2019-01-01 | 广州小鹏汽车科技有限公司 | A kind of Android APP starting velocity optimization method and system |
| CN111061516B (en) * | 2018-10-15 | 2021-09-14 | 华为技术有限公司 | Method and device for accelerating cold start of application and terminal |
| CN109918145B (en) * | 2019-01-10 | 2022-05-20 | 北京字节跳动网络技术有限公司 | Application cold start acceleration method and device and electronic equipment |
| CN112527403B (en) * | 2019-09-19 | 2022-07-05 | 荣耀终端有限公司 | Application starting method and electronic equipment |
| CN110990075B (en) * | 2019-11-18 | 2023-08-29 | 北京小米移动软件有限公司 | Method, device, equipment and storage medium for starting fast application |
| CN111427630B (en) * | 2020-03-31 | 2024-03-22 | 北京金堤科技有限公司 | Cold start optimization method and device, electronic equipment and storage medium |
| CN111767123B (en) * | 2020-05-07 | 2023-09-01 | 北京奇艺世纪科技有限公司 | Operation optimization method and device |
| CN113722011B (en) * | 2021-09-01 | 2024-05-17 | 广州市百果园网络科技有限公司 | Application interface starting method, device, equipment and storage medium |
| CN113835782B (en) * | 2021-09-23 | 2024-09-24 | 掌阅科技股份有限公司 | Application starting method, electronic equipment and storage medium |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101923479A (en) * | 2010-09-08 | 2010-12-22 | 青岛海信移动通信技术股份有限公司 | Mobile terminal and method for controlling screen display when starting terminal |
| CN103425225A (en) * | 2012-05-16 | 2013-12-04 | 腾讯科技（深圳）有限公司 | Device and running method for applications in operating system of portable data equipment |
| CN103544059A (en) * | 2013-07-16 | 2014-01-29 | Tcl集团股份有限公司 | Implementation method and system for awaiting and buffering effect at time of application switching |
| CN104484456A (en) * | 2014-12-29 | 2015-04-01 | 哈尔滨工业大学 | Multi-threading parallel-based rapid loading method for SQLite database |
| CN105630543A (en) * | 2015-12-21 | 2016-06-01 | 北京奇虎科技有限公司 | Application cold start acceleration method and apparatus |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103955388B (en) * | 2014-04-29 | 2017-09-12 | 百度在线网络技术（北京）有限公司 | The cold start-up method and device of client |
| CN104199684B (en) * | 2014-08-13 | 2018-01-12 | 百度在线网络技术（北京）有限公司 | The implementation method and device of browser cold start-up |
-
2016
- 2016-10-13 CN CN201610896161.2A patent/CN106445617B/en not_active Expired - Fee Related
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101923479A (en) * | 2010-09-08 | 2010-12-22 | 青岛海信移动通信技术股份有限公司 | Mobile terminal and method for controlling screen display when starting terminal |
| CN103425225A (en) * | 2012-05-16 | 2013-12-04 | 腾讯科技（深圳）有限公司 | Device and running method for applications in operating system of portable data equipment |
| CN103544059A (en) * | 2013-07-16 | 2014-01-29 | Tcl集团股份有限公司 | Implementation method and system for awaiting and buffering effect at time of application switching |
| CN104484456A (en) * | 2014-12-29 | 2015-04-01 | 哈尔滨工业大学 | Multi-threading parallel-based rapid loading method for SQLite database |
| CN105630543A (en) * | 2015-12-21 | 2016-06-01 | 北京奇虎科技有限公司 | Application cold start acceleration method and apparatus |
Also Published As
| Publication number | Publication date |
|---|---|
| CN106445617A (en) | 2017-02-22 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN106445617B (en) | Android-based application cold start optimization method and system | |
| CN106775699B (en) | Method and system for updating UI in asynchronous thread | |
| WO2017080273A1 (en) | Task management methods and system, and computer storage medium | |
| US9354856B2 (en) | Software installation method and device | |
| US9582320B2 (en) | Computer systems and methods with resource transfer hint instruction | |
| CN110569121B (en) | Multithreading concurrent processing method and device based on application robot | |
| CN108717380B (en) | Message processing method and device | |
| CN107479981B (en) | Processing method and device for realizing synchronous call based on asynchronous call | |
| CN111209046A (en) | Multitask-oriented embedded SPARC processor operating system design method | |
| CN109413502B (en) | Multithreading barrage message distribution method, device, equipment and storage medium | |
| CN110908724A (en) | Android App starting method and related components | |
| WO2018099356A1 (en) | Method and system for analysing operation fluency of android terminal application | |
| CN109117203A (en) | A kind of Android APP starting velocity optimization method and system | |
| CN106708614B (en) | multithreading creating system and method and multithreading processing system and method | |
| CN109885340A (en) | A kind of application program cold start-up accelerated method, device, electronic equipment | |
| CN103150503A (en) | Trojan scanning method and Trojan scanning device | |
| CN112650541A (en) | Application program starting acceleration method, system, equipment and storage medium | |
| CN106874010B (en) | Method for rapid page loading of ListView in Android system | |
| CN112346835B (en) | Scheduling processing method and system based on coroutine | |
| CN110955503A (en) | Task scheduling method and device | |
| CN112860401A (en) | Task scheduling method and device, electronic equipment and storage medium | |
| CN112395062A (en) | Task processing method, device, equipment and computer readable storage medium | |
| CN112395015A (en) | Optimization method and device for accelerating startup based on Android system | |
| CN108810645B (en) | Bullet screen message distribution method, device, equipment and storage medium | |
| US6832376B1 (en) | Method and apparatus for resuse of a thread for different programmed operations |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| CF01 | Termination of patent right due to non-payment of annual fee |
Granted publication date: 20200804 |