Based on what I study, iOS uses most(all) of system frameworks as dynamic frameworks. Does iOS load all of them when an app launches? Or iOS may load it later when iOS actually need the framework?
The advantage of loading it when an app launches: Save more time when iOS calls the functions in the dynamic frameworks.
The advantage of loading it lazily: Save more memory.
Or iOS may load it later when iOS actually need the framework?
The Wikipedia page on dynamic linking covers both the general idea and a number of details specific to various popular operating systems. It says (in part) this about Darwin, including macOS and iOS:
The executables on the macOS and iOS platforms often interact with the dynamic linker during the execution of the process; it is even known that an executable might interact with the dynamic linker, causing it to load more libraries and resolve more symbols, hours after it initially launches.
Furthermore, if you read the man page for dyld, the dynamic loader, you'll find an environment variable called DYLD_BIND_AT_LAUNCH that is described thus:
When this is set, the dynamic linker binds all undefined symbols the program needs at launch time. This includes function symbols that can are normally lazily bound at the time of their first call.
A final piece of evidence is in Apple's Overview of Dynamic Libraries document, which says in part:
When an app is launched, the OS X kernel loads the app’s code and data into the address space of a new process. The kernel also loads the dynamic loader ( /usr/lib/dyld ) into the process and passes control to it. The dynamic loader then loads the app’s dependent libraries. These are the dynamic libraries the app was linked with. The static linker records the filenames of each of the dependent libraries at the time the app is linked. This filename is known as the dynamic library’s install name.
And in the next paragraph:
The dynamic loader resolves only the undefined external symbols the app actually uses during the launch process. Other symbols remain unresolved until the app uses them.
Given all that, it sounds like iOS probably loads each dynamic framework as part of the process of launching an app, but defers actually binding undefined names in the app to definitions in the framework until it's actually needed.
Apple doc says:
A framework is a bundle (a structured directory) that contains a dynamic shared library along with associated resources, such as nib files, image files, and header files. When you develop an application, your project links to one or more frameworks. For example, iPhone application projects link by default to the Foundation, UIKit, and Core Graphics frameworks. Your code accesses the capabilities of a framework through the application programming interface (API), which is published by the framework through its header files. Because the library is dynamically shared, multiple applications can access the framework code and resources simultaneously. The system loads the code and resources of a framework into memory, as needed, and shares the one copy of a resource among all applications.
