A brief discussion on performance optimization in Android

Performance optimization is a big topic. If someone asks you how to optimize performance in Android, you may not know where to start. The first thing to understand is why our App needs to be optimized. The most obvious moment is when the user says, "What the hell, it's not working for me after so long, I'll just unfollow and uninstall it."

[[148281]]

What does this have to do with? Let's make a pale rebuttal. Damn, the user's device is old and the network is bad. It has nothing to do with me. There is no need to optimize it. However, the boss made the decision and put pressure on the CTO. Then the CTO came to you and said: You must find a way to optimize it for me today, otherwise you are not allowed to go home.

Well, why does the app seem to be stuck, slow, and messy from the appearance of the UI? Let's try to analyze it.

Off topic: Change minSDK to 4.0+, go to the low-level users, they don't even want to change their phones, how much revenue can you expect it to bring you, just pass it. There are many system bugs before 4.0, and you can't reduce the overall high performance to make up for these bugs.

Ok, let's start with the UI:

The first thing to understand is the UI drawing process: measure-layout-draw. Both measure and layout require a for loop to gather all the child controls to complete the drawing and layout. Therefore, the more child controls there are, the longer it will take (inflate, layout_weight, relative, multi-layer nesting, etc.). It is necessary to reduce unnecessary child controls or levels. You can reduce the nesting of levels through the merge and viewstub tags. If your spatial concept is not so good, you can use the HierarchyViewer tool to check.

For multi-item components such as Listview or GridView, reusing items can reduce the number of inflation times. Reuse can be achieved through the ViewHolder method of setTag and getTag. It should be noted here that the controls in the holder are best reset before assigning values ​​to avoid confusion of images and texts.

There are several ways to optimize the ViewPager for the first time display and left and right sliding freezes:

• The best minimum number of pages that ViewPager caches at the same time is 3. If there are too many, then when it is displayed for the first time, there will be many pagers initialized by ViewPager, so the cumulative rendering time of the pager will increase, and it will look stuck.
• Each pager should only load the network or database when it is displayed (UserVisibleHint=true). It is best not to preload data to avoid waste.

What should I do if the image cannot be displayed or takes too long to load? It is divided into two parts: download speed and loading speed .

For downloading, it is necessary to control the maximum number of tasks that can be downloaded simultaneously (the average speed is slow). At the same time, wrapping the InputStream with a layer of buffer stream will be faster (such as BufferedInputStream).

Regarding loading speed , we need to know that although the downloaded image may be only a few hundred KB, the memory occupied by decoding it into a bitmap is doubled. Reducing the image size as much as possible is the fundamental factor. Letting the server provide images of different resolutions is the best solution. Memory will always run out. Don't always think that a larger resolution will be clearer. In fact, there is only 150*150 space. It is inappropriate to get a 1000*1000 image. In addition, in terms of loading speed: memory>hard disk>network, the reasonable use of memory cache is also the key. If you can't write it well, it doesn't matter. There are so many open source image cache frameworks, so you don't have to worry about it yourself.

Let’s talk about cache

There are many ways to cache, and there is no need to list them all. What we want to talk about is the combination of them.

For example, we used to use strong references and HashMap, but later we found that they took up memory, so we used soft references and weak references to recycle in time. Later, because the recycling mechanism was uncontrollable, lrucache and disklrucache were introduced to balance memory and disk cache through algorithms. As Android versions advance and evolve, we should also embrace change. If there are still soft references and weak references in your app, you may wish to check again.

For example, network + database. We usually actively obtain network data rather than passively accept it. What if the data is repeated or unchanged? What's the point of getting network data? My solution is to set a maximum request interval for each activity or fragment or each component. For example, when a listview requests data for the first time, save a copy to the database and record the timestamp. When it is reinitialized next time, determine whether it exceeds the maximum time interval (such as 5 minutes). If not, only load the database data without making another network request. Of course, there are also some implicit http request frameworks that cache server data and no longer request the network within a certain period of time, or directly return the previously cached data when the server returns 304.

Since we are talking about the Internet, let’s talk about

There are many ready-made HTTP frameworks for us to use. We can handle a URL request almost only by writing configurations, but there are many things that require cooperation from the server, such as: json data format, WebP instead of jpg, support for breakpoint resumption, merging multiple requests into one, avoiding redirection as much as possible, server caching and load balancing, etc.

For the client itself, in addition to the above implementation, we also need reasonable caching, controlling the maximum concurrent request volume, canceling expired requests in a timely manner, filtering duplicate requests, setting timeouts, setting request priorities, etc.

Optimization is not a one-person job. It is easy to implement a function, but it is not easy to optimize and reconstruct it. It requires multi-faceted prediction and joint debugging. Reasonable assumptions and practices are the most important means of optimization.

After talking about these specific points, let's talk about some common sense, or so-called coding standards.

• You should know that you should not declare temporary variables in a for loop, and do not write try catch in it unless it is absolutely necessary.
• Understand the garbage collection mechanism, avoid frequent GC, memory leaks, and OOM (I will talk about this in detail when I have a chance)
• Use data types properly, such as StringBuilder instead of String (the most common test question is str+="str" ​​with several objects), use less enumerations, and use less parent class declarations (List, Map)
• If you have frequent new threads, it is best to execute them through the thread pool to reduce the thread creation overhead.
• You need to know the benefits of a singleton and use it correctly.
• Use more constants, less explicit "action_key", and maintain a constant class instead of declaring them repeatedly.
• If possible, at least understand the strategy pattern, composite pattern, decorator pattern, factory pattern, and observer pattern in design patterns. These can help you decouple properly, so that even if the requirements change frequently, you don't have to be afraid of affecting the whole system. Requirements changes are not terrible, what is terrible is not making a reasonable design before writing code.

Of course, there are many more. What Stay said is just a general outline. You still need to keep trying. There is a big difference between being able to develop and write code and being able to make products. The attitude alone can kill 80% of programmers. When you encounter some areas that need to be optimized, analyze them patiently. The accumulation of time will make you a real engineer.

In addition, there is no absolute perfection in optimization. Each optimization is done based on the current environment. We must understand that communication is the best optimization. Don’t be blindly obedient or casual, and think twice before acting.

How to optimize performance on Android? You will probably know the answer after writing code for three years.

Original link: http://www.cnblogs.com/stay/p/4784014.html