In the previous article, there are many performance and memory tips that need to be noted in the development of Android apps. This article is an analysis of performance optimization and memory optimization issues from the Smali instruction level.
How to solve the problem of high interface start time overhead
When we write Android applications, there are many situations where the interface is too long to start and the user experience is very bad. So when we write code, we must pay more attention to how to improve the start time of the interface. Here are a few tips on how to optimize the interface startup overhead.
1. Load overhead for classes
When a static method or static property of a class is called or the class is instantiated, the first thing the virtual machine does is dexclassloader the class file to the virtual machine, and the process of loading into the virtual machine triggers the execution of the Clinit function in the class file. Let's look at the following section of code
[CPP]View PlaincopyPost-compilation Smali files
[HTML]View PlaincopyIn the Java file above, we declare a number of variables, including strings, integers, arrays of strings, some of which declare final, and some do not declare final. We can see that the final string and integer are declared, the compiled file has become a constant, and no final variable is declared, and we can see that the default value of string, which is still the type default value, is null at the point where it is declared, and the default value of int is 0. So when Dexclassloader loads the class file, it will initialize the values for the above static variables in the <clinit> function. We can see that a number of static variables are declared, in the compiled Smali file, become more Smali instructions.
Increasing the speed of the Dexclassloader loading class is to improve the execution speed of the <clinit> function in class.
Through the above analysis we can summarize the following rules:
Declare a static variable, be sure to add a final declaration (the compiler variable is replaced by the constant, it will not load the CPU time when the class loaded)
2. Creating instance overhead for classes
In addition to static variables in a class file, there are many global non-static variables. When we declare global variables, we assign values to global variables.
[CPP]View Plaincopy
This Java statement above will become a few instructions in the Smali file. Let's take a look at:
As you can see, in the <init> function, the global non-static variables are initialized. Class file is the process of executing the <init> function when creating instances of classes.
The process of improving the class creation instance is the process of optimizing <init> function execution speed. Our best practice is to assign a default value where the global variable is declared, and then initialize it when it is actually used in the function.
Whether we are static global variables or non-static global variables, these variables are assigned during class loading and instantiation. If we assign a value at the time of the declaration, we assign a value to the INIT function, or else an assignment of NULL or 0 is executed. Therefore, it is a great rule to declare global variables as few as possible. (because whenever a global variable is declared, an instruction is executed when the class is loaded or initialized.) )
The above two points are optimized, I believe that the display speed of the interface to improve a lot.
But when we need to define a set or array of constants in our code, how can we avoid the overhead of these two processes? For example, in development, we need to define a static global array. If defined in a class that is instantiated in the activity's oncreate, it will certainly consume a lot of activity startup time. How do you optimize for this problem? We can refactor this static array into another class, and we can call the static array in this class directly when we use the array. This avoids the problem of initializing the majority of groups in the activity initialization process.
Lazy initialization is a powerful technique for optimizing activity startup time. On the basis of not modifying the algorithm and the logical structure, the delay initialization can also achieve a certain degree of optimization.
Through the above analysis can summarize the following several rules:
1. Declare global variables as few as possible
2. Declaring a static variable must be a final statement
3. For large overhead static modules or global non-static modules, can be refactored into another class, to achieve the role of lazy initialization.
Excerpt from: http://blog.csdn.net/litton_van/article/details/21872677
Go Android High Performance Programming (2)--deferred initialization
Start building with 50+ products and up to 12 months usage for Elastic Compute Service
1 on 1 presale consultation
24/7 Technical Support 6 Free Tickets per Quarter Faster Response
Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.
A comprehensive suite of global cloud computing services to power your business
Payment Methods We Support
