iOS Development - Exploring the Block Principle

1. Overview

In iOS development, everyone is familiar with block, which is an implementation method of closure in iOS development. It can encapsulate a piece of code logic so that it can be passed, stored, and called like data, and can save related context status.

Many articles on block principles are relatively old, and some of the knowledge they cover is outdated. Here, we will use the new version of the iOS SDK to sort out the block principles again, and also review the existing knowledge with everyone.

2. Memory layout

Block can be understood as a structure in essence. The memory layout of the structure is represented by a diagram. The order of the fields in the diagram follows the order of layout:

• isa: block also has isa, which is also an object in terms of memory structure. isa points to the class object of block, such as __NSMallocBlock__, which will be discussed in subsequent articles;
• flags: used to store some flag information, such as whether to capture external variables;
• reserved: A system reserved field that may be used for some compilation optimization flags or to store some temporary variables.
• Invoke: function pointer, pointing to the function address to be executed by the block, that is, the function address corresponding to the block code block;
• descriptor (now called desc): points to block_desc_0, contains block size, captured external variable layout information, and related function pointers for increasing reference counts and destroying them;
• variables: External variables captured by the block.

picture

3. Type

Since blocks are also objects, their types can be obtained through the class method, that is, class objects. Blocks have the following three types:

• __NSGlobalBlock__, there is no block to access auto variables, but it is OK to access static variables. This type of variable is meaningless. If you don't need to use auto variables, writing them as methods can meet your needs.
• __NSStackBlock__, in MRC environment, when auto variables are accessed, they will be placed in the stack area by default. You need to manually copy them to the heap area. In ARC environment, they will be automatically copied to the heap area after accessing auto variables;
• __NSMallocBlock__, memory is managed by the developer himself and will not be released by the system.

Blocks are mainly allocated in three areas: heap area, stack area, and global area. The data in the global area is stored in the data segment.

Blocks will exist in different memory areas in different scenarios. In MRC, a block is first created in __NSStackBlock__ memory, and then we use the copy method to copy the block to __NSMallocBlock__ memory for memory management. Later in ARC, the system has done the copy operation for us, and the created block will be automatically copied to __NSMallocBlock__ memory. The block in the heap area also has the concept of reference counting. If no external parameters are used in this block, the system will store this block in __NSGlobalBlock__ memory.

picture

And blocks also have inheritance relationships. For example, in the following TestBlock example, its parent class is __NSGlobalBlock__, and the parent class of all blocks is NSBlock, which inherits from the NSObject class. In earlier iOS systems, there was an additional __NSGlobalBlock relationship between __NSGlobalBlock__ and NSBlock (without an underscore).

picture

4. Convert C++

Next, we use the clang command to convert the block into a structure to analyze its specific implementation. Although this is not the code that will eventually run on the iOS system, it is an intermediate form of expression, and subsequent compilation, linking and optimization will form an ipa package that runs on the phone, but it is very helpful for us to understand the implementation principle of the block.

4.1 Conversion Commands

xcrun is a tool set used by Xcode to find and execute related command lines. It can better execute clang commands and reduce errors.

 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc [源文件路径] -o [目标文件路径]

The clang command has the following key parameters:

• -fobjc-arc: If the project is in ARC or ARC and MRC mixed environment, this parameter needs to be modified to indicate that the conversion is performed in ARC mode. If the ARC environment is not required, it can be ignored.
• -x objective-c++: This parameter is not used above. If you include Objective++ source files, you need to use this parameter to ensure that clang can distinguish between OC and C++ code;
• -rewrite-objc: tells clang to rewrite in C++, including the upper-level code, which clang will present as the underlying code;
• [Target file path]: This is an optional parameter. If not passed, a cpp file with the same name will be generated in the current directory by default, for example, main.m corresponds to main.cpp.

4.2 Conversion Examples

Below, a very simple block is implemented in main.m, and no external variables are captured. Use the clang command to view the C++ code and observe the specific implementation principle of the block.

picture

After conversion, pull the C++ source file to the bottom, you can see the main function and the implementation of TestBlock. There are many escape codes in the main function. After deleting them, the logic will be clearer.

picture

5. Structure

5.1 Infrastructure

The converted code looks complicated, but we only look at the key information, and the __main_block_impl_0 constructor can also be removed. After sorting, the following three structures are obtained. Without including external variables and __block, the fields of the block structure are so simple, and the key ones are isa, Block_size, and FuncPtr.

picture

We can also print the relevant fields of the block structure, but since the block structure is not declared in a .h file, we need to paste the structure converted by clang into the corresponding file and make a display declaration. Then use the __bridge method to bridge the block object to the structure declared by itself, and then print the corresponding fields.

picture

The impl.FuncPtr in the structure stores the callback function address. From the address, we can see that it is a virtual address. The block structure is stored in the heap area.

picture

5.2 Calling part

After reading the definition of the block structure, we come to the main function to see how the block is implemented and what it looks like after the call conversion. Remove all the block-related conversions in the main function, and the result is as shown in the red circle. In essence, there are two steps. The first step is to call the __main_block_impl_0 structure constructor, and the second step is to call the function pointer of the structure.

picture

The constructor called in the first line of the main function is the C++ constructor declared in the __main_block_impl_0 structure. Since we are creating a simplest block, we can see that the storage area of ​​the block is in the stack area. That is, after the main function is called, the block life cycle ends.

picture

The __main_block_impl_0 constructor has two parameters. The first red circle part is the address of the passed function pointer. The function corresponds to the implementation code inside the block. The second parameter is the __main_block_desc_0_DATA structure, which is defined as __main_block_desc_0, and the first parameter is passed 0 by default. The second parameter is the size of the block structure, which is the size of the __main_block_impl_0 block structure itself. The third parameter has a default value and can be left blank.

picture

The __main_block_desc_0 structure is a compact way of writing. After declaring the __main_block_desc_0 structure, a variable named __main_block_desc_0_DATA is declared. The variable type is a static variable, and the initialization-related code is implemented.

picture

At the code location where the block is executed, you can see that it is not called in the form of block->impl.FuncPtr, but directly called in the form of block->FuncPtr, which misses a step in the middle.

Strictly speaking, impl should be added, but there will be no problem if it is not added. This is because, if you look at the original clang code without deleting the conversion code, you can see that block is converted to __block_impl, that is, it is treated as __block_impl. If we look at the structure definition of __main_block_impl_0, __block_impl is the first member variable, so there is no problem accessing FuncPtr, as long as Desc is not accessed.

6. External variables

6.1 Value Types

If we add an external variable to the block call, what will the structure look like?

picture

Through the clang command, we can see that a field with the same name is added to the converted __main_block_impl_0. This is very simple and does not need to be explained in detail. It is passed in the __main_block_impl_0 constructor and the value parameter is initialized through the initialization list after the colon.

picture

The subsequent parameter passing and usage are all structure assignment and value retrieval logic, which is very simple.

picture

6.2 Value Transfer

The following writing method is easy to make mistakes when using blocks. When the value parameter is used in a block and the value parameter is printed, the result is 1 instead of 2.

picture

From the C++ source code we can see that this is because if the external variable referenced by the block is a value type, the value will be directly copied instead of a pointer reference.

picture

The solution to this problem is very simple. By modifying the value type with __block, the value inside the block and the external value parameter can be unified.

picture

6.3 Static variables

Let's see what the structure will be implemented if a static variable modified by static is captured.

picture

After converting to C++ code, you can see that the original value passing has become address passing. The reference of value in __main_block_impl_0 is a pointer reference, and the address of value is passed in the main function. If the static modifier is an object itself, the object is referenced by a pointer, which is referenced by two asterisks in the block structure. That is, NSObject **obj.

picture

Due to the implementation of static variable address transfer, static variables can be directly modified within the block without the need to modify them with __block.

picture

6.4 Global Variables

If value is changed to a global variable, what changes will occur in the structure?

picture

Because the scope of global variables is large, they can be accessed without the need for a block to hold them separately, and no new fields will be added to the structure.

picture

6.5 Object Type Variables

If the block references an object instead of a basic data type, what is the definition of the structure?

picture

Execute the clang command, and the structure is as shown below. The code below removes the conversion and organizes the code. You can see that there are two more function pointers, __main_block_copy_0 and __main_block_dispose_0.

Taking the implementation of copy __main_block_copy_0 as an example, after execution, the implementation of Block_object_assign will be called. In the implementation, the system will call the corresponding memory management method according to the reference method of person, __strong, __weak, __unsafe_unretained, whether it is a strong reference or a weak reference.

The __main_block_dispose_0 function is called when the block is removed from the heap area. When dispose is called, the Block_object_dispose function will be called. The function will reduce the reference count or release the object according to the reference method of person.

Both copy and dispose functions have a parameter 3, which is a flag indicating the type of the external variable. Here, BLOCK_FIELD_IS_OBJECT indicates an object type, BLOCK_FIELD_IS_WEAK indicates a weak reference variable, BLOCK_FIELD_IS_BLOCK indicates a block type variable, and so on.

picture