Preface
What are the main reasons for performance problems? There are the same and different reasons, but in the final analysis, it is nothing more than problems such as memory usage, code efficiency, appropriate policy logic, code quality, and installation package volume.
But from the perspective of user experience, when we have to play an application as a user, what do we care about? If you are playing a mobile game, you must first not want to suddenly crash while playing, then you do not want to get stuck, secondly, the power consumption and traffic consumption do not want to be too serious, and finally, the installation package is hoped to be smaller. The simple classification is as follows:
Fast: Avoid lag during use, fast response speed, reduce user waiting time, and meet user expectations.
Stable: Do not crash or respond during user use.
Save: Save traffic and power consumption, reduce user usage costs, and avoid causing the phone to get hot during use.
Small: Small installation package can reduce the installation cost of users.
1. Quick
The application is slow to start and often stuttered when used, which is very affecting the user experience and should be avoided as much as possible. There are many scenes that are stuck, and they can be divided into 4 categories according to the scene: UI drawing, application startup, page jump, and event response. There are many reasons for the lag, but no matter what the reasons and scenarios are, they are ultimately displayed on the device screen to reach the user. In the final analysis, there is a problem with the display.
According to the iOS system display principle, it can be seen that the root causes affecting drawing are as follows:
1. The drawing task is too heavy, and drawing a frame of content takes too long.
2. The main thread is too busy, and the data is not ready when the VSYNC signal is transmitted from the system, resulting in frame loss.
Drawing takes too long, and there are some tools that can help us locate the problem. If the main thread is too busy, you need to pay attention. The main thread's key responsibility is to handle user interaction, draw pixels on the screen, and load and display relevant data. Therefore, it is especially necessary to avoid any main thread's matters so that the application can maintain an instant response to user operations. To sum up, the main thread mainly does the following aspects:
Lifecycle control
2. System event processing
3. Message processing
4. Interface layout
5. Interface drawing
6. Interface refresh
In addition, other processing should be avoided in the main thread, especially complex data calculations and network requests.
2. Stability
The stability definition of an application is very broad, and there are many reasons that affect stability. For example, unreasonable memory usage, incomplete consideration of code exception scenarios, and unreasonable code logic, etc., will affect the stability of the application. The two most common scenarios are: Crash and ANR. These two errors will make the program unusable. The most common solutions are as follows:
1. Improve code quality. For example, code review during development, look at some code design logic, business rationality, etc.
2. Code static scanning tool. Common tools include Clang Static Analyzer, OCLint, Infer, etc.
monitor. Record some crash information and abnormal information in a timely manner for subsequent analysis and resolution.
Upload mechanism. After Crash, try to save the log to the local area first, and then upload the log information the next time the network is normal.
3. Save
In mobile devices, the importance of batteries is self-evident, and nothing can be done without electricity. For operating system and device developers, power consumption optimization is consistent and does not stop, pursuing longer standby time. For an application, the power usage problem cannot be ignored, especially those that are classified as "battery killers", the final result is uninstallation. Therefore, while implementing the needs, application developers need to minimize the power consumption.
Regardless of whether the user is using it directly or not, the CPU is the main hardware used by the application. When operating and processing push notifications in the background, the application will still consume CPU resources.
The more you apply the calculation, the more power you consume. When completing the same basic operation, older generation devices will consume more power, and the consumption of the calculation depends on different factors.
2. Network
Intelligent network access management can make applications respond faster and help extend battery life. When the network is not accessible, subsequent network requests should be postponed until the network connection is restored. In addition, high-broadband consumption operations should be avoided without WiFi connection. For example, video streaming, as we all know, cellular wireless systems (LTE, 4G, 3G, etc.) consume much more power than WiFi signals. The root cause is that LTE devices are based on multiple input and multiple output technologies, using multiple concurrent signals to maintain LTE links on both ends. Similarly, all cellular data links are scanned regularly to find stronger signals. Therefore: we need
1) Before performing any network operation, check whether the appropriate network connection is available
2) Continuously monitor the availability of the network and give appropriate feedback when the link status changes
3). Positioning Manager and **GPS**
We all know that positioning services are very power-consuming, and using GPS to calculate coordinates requires two points of information to determine:
1) Time lock Each GPS satellite broadcasts a unique 1023-bit random number per millisecond, so the data propagation rate is 1.024Mbit/s. The receiving chip with GPS must be correctly aligned with the satellite's time lock slot.
2) Frequency lock GPS receiver must calculate the signal error caused by the Doppler offset caused by the relative motion of the receiver and the satellite
Calculating coordinates will constantly use the hardware resources of CPU and GPS, so they will quickly consume battery power, so how can they reduce it?
1) Turn off irrelevant features
Determine when you need to track the change of location, call the startUpdatingLocation method when you need to track, and call the stopUpdatingLocation method when you do not need to track.
Location tracking should also be turned off when the app is running in the background or when the user is not chatting with others. That is to say, when browsing media libraries, viewing friend lists or adjusting application settings, location tracking should be turned off.
2) Use the network only if necessary
In order to improve the efficiency of power usage, IOS always keeps the wireless network off as much as possible. When an application needs to establish a network connection, IOS will take this opportunity to share network sessions with the backend application so that some low priority can be processed, such as push notifications, emails, etc.
The key is that whenever a user establishes a network connection, the network hardware will maintain an activity time of several seconds after the connection is completed. Each centralized network communication consumes a lot of power.
To alleviate the harm caused by this problem, your software needs to use the network with some reservations. You should use the network regularly and temporarily, rather than keeping active data flows continuously. Only in this way can the network hardware have the opportunity to shut down
4. Screen
The screen consumes a lot of power, and the larger the screen, the more power it consumes. Of course, if your application runs in the foreground and interacts with users, it will inevitably use the screen and consume power.
Here are some solutions to optimize the use of the screen:
1) Animation optimization
When the application is in the foreground, use animations and once the application enters the background, the animation is paused immediately. Generally speaking, you can pause or stop the animation by listening to the notification events of UIApplicationWillResignActiveNotification or UIApplicationDIdEnterBackgroundNotification, or restore the animation by listening to the notification events of UIApplicationDidBecomeActiveNotification
2) Video optimization
During video playback, it is best to keep the screen constant. This can be achieved using the idleTimerDisabled property of the UIApplication object. Once YES is set, it will prevent the screen from hibernating, thus achieving constant light.
Similar to animation, you can release and acquire locks through notifications from the corresponding app
Users always carry their phones with them, so it is particularly important to write power-saving codes. After all, mobile phones’ mobile power supply is not everywhere. When it cannot reduce the complexity of tasks, providing a solution that is sensitive to battery power and prompting the user at the right time will make the user experience good.
4. Small
The size of the application installation package has no effect on the use of the application, but the larger the application installation package, the higher the threshold for users to download. Especially in the case of mobile networks, users have higher requirements for the size of the installation package when downloading the application. Therefore, reducing the size of the installation package can make more users willing to download and experience the product.
Of course, although slimming and reducing burdens are good, you need to pay attention to the impact of slimming on the maintainability of the project. It is recommended to select skills based on your own project.
The App installation package consists of two parts: resources and executable files. The installation package is optimized from the following three parts.
Resource optimization:
1. Delete useless resources
2. Delete duplicate resources
3. Lossless compression pictures
4. Replace uncommon resources with downloads
Compilation optimization:
1. Remove debug symbols
2. Turn on compilation and optimization
3. Avoid compiling multiple architectures
Executable file optimization:
1. Remove useless code
2. Statistics library occupation, remove useless library
3. Obfuscated class/method name
4. Reduce redundant strings
->MRC (It is generally not recommended to do this unless otherwise not in special circumstances, as it will increase maintenance costs)
Reducing the size of iOS installation packages is something that many medium and large APPs need to do. Generally, they will start with resource files first, compress pictures/audio, and remove unnecessary resources. After these resource optimizations are completed, we can also try to slim the executable file. The larger the project, the larger the executable file occupies. Because the AppStore will encrypt the executable file, the compression rate of the executable file is low. After compression, the proportion of the volume of the entire APP installation package is about 80% to 90%, which is quite worth optimizing.
Here are some common optimization solutions:
TableViewCell Reuse
When the cellForRowAtIndexPath: callback is called, only the instance is created, the cell is quickly returned, and the data is not bound. Bind data (assignment) when willDisplayCell: forRowAtIndexPath:.
Highly cached
When the tableView slides, heightForRowAtIndexPath: will be called continuously. When the cell height needs to be adapted, the height must be calculated every callback, which will cause UI to be stuck. To avoid repeated meaningless calculations, cache heights are required.
How to cache?
Dictionary, NSCache.
UITableView-FDTemplateLayoutCell
[if !supportLineBreakNewLine]
[endif]
View level optimization
Don't create views dynamically
Cache subview under the premise that memory is controllable.
Make good use of hidden.
[if !supportLineBreakNewLine]
[endif]
Reduce view hierarchy
Reduce the number of subviews and draw elements with layer.
Use clearColor, maskToBounds, shadow effects, etc. less.
[if !supportLineBreakNewLine]
[endif]
Reduce unnecessary drawing operations
picture
Do not use JPEG pictures, you should use PNG pictures.
The child thread is pre-decoded (Decode), and the main thread is directly rendered. Because when the image does not have a Decode, directly assigning the value to the imageView will perform a Decode operation.
Optimize the image size and try not to scale dynamically (contentMode).
Combine as many pictures as possible into one for display.
[if !supportLineBreakNewLine] [endif]
Reduce transparent view
Using transparent view will cause blending. In iOS graphics processing, blending mainly refers to the calculation of mixed pixel colors. The most intuitive example is that we superimpose two layers together. If the first layer is transparent, the final pixel color calculation needs to take the second layer into account. This process is Blending.
Causes of blending:
UIView's alpha<1.
The image of the UIImageView contains an alpha channel (even if the alpha of the UIImageView is 1, it will still cause blending as long as the image contains a transparent channel).
[if !supportLineBreakNewLine] [endif]
Why does blending cause performance losses?
The reason is very intuitive. If a layer is opaque, the system can directly display the color of the layer. If the layer is transparent, more calculations will be caused because another layer needs to be included in it and the color calculation after mixing is performed.
The opaque is set to YES to reduce performance consumption, because the GPU will not do any synthesis, but will simply copy from this layer.
[if !supportLineBreakNewLine] [endif]
Reduce off-screen rendering
Off-screen rendering refers to the need to render the image before it is drawn to the current screen, and then it is drawn to the current screen.
In OpenGL, there are two ways to render GPU screens:
On-Screen
Rendering means the current screen rendering, which means that the rendering operation of the GPU is performed in the currently used screen buffer for display.
Off-Screen
Rendering means off-screen rendering, which refers to the GPU opening a new buffer outside the current screen buffer for rendering operations.
[if !supportLineBreakNewLine] [endif]
summary
Performance optimization cannot be solved by updating one or two versions. It is a continuous requirement and continuous integration and iterative feedback. In actual projects, at the beginning of the project, due to the manpower and project completion time constraints, the priority of performance optimization is relatively low. When entering the project's input stage, the priority needs to be improved. However, in the early stage of the project, when designing the architectural plan, the points of performance optimization need to be considered in advance, which reflects a programmer's technical skills.
When to start the need for performance optimization, it often starts by discovering the problem, then analyzing the cause and background of the problem, and then finding the optimal solution, and ultimately solving the problem. This is also a method of handling that is often used in daily work.
OK, the above is the entire content of this article. I hope that the content of this article has certain reference value for your study or work. Thank you for your support.