Naming rules: __ Class name __ method name _block_IMPL_ Hierarchy
As you can see from the above code, the block is compiled into a __TestCode__testFunc_block_impl_0 structure
It has an internal constructor of the same name__TestCode__testFunc_block_impl_0
Two attributes
__block_impl impl
__TestCode__testFunc_block_desc_0* Desc
2. __block_impl
struct __block_impl {void *isa;// This points to &_NSConcretestackBlockint Flags;
int Reserved;
void *FuncPtr; // The storage nature of the method is a __TestCode__testFunc_block_func_0 C function
};
Copy the code
You can see that there is an ISA pointer inside the __block_impl structure. So you can prove that a block is essentially an OC object.
The isa pointer to the __block_impl structure holds the &_NSConcretestackblock address. Block is of type _NSConcreteStackBlock.
Seeing ISA reminds us of objc_class, so our block is essentially an object too. We know that instance objects -> class objects -> metaclasses form one of the ISA chains, and the __block_impl structure occupies the place of the middle class object
The ISA pointer here will point to the metaclass, which is mainly used to describe the storage area of the block
__TestCode__testFunc_block_func_0
staticvoid __TestCode__testFunc_block_func_0(struct __TestCode__testFunc_block_impl_0 *__cself) {
printf("Block test code");
}
Copy the code
__TestCode__testFunc_block_func_0 holds the code in the block
The above analysis is that the block does not hold any external variables, but when the block holds external variables, it generates something extra.
Holds basic data types
The basic data types held are divided into whether or not __block is used, as follows: A is __block and B is not.
- (void)testFunc { __block NSInteger a = 0; NSInteger b = 0; self.block111 = ^{ a = 12 + b; Printf (" Block test code "); }; self.block111(); }Copy the code
thinking
A is changed from a value to an address by __block.
__bloktheaWhat structure is encapsulated?
structureaWhere exactly is the value of?
structureaHow is memory managed?
To answer these questions, we need to look- (void)testFunc{}Compiled source code:
The compiled:
staticvoid _I_TestCode_testFunc(TestCode * self, SEL _cmd) {
__block NSInteger a = 0;
__attribute__((__blocks__(byref))) __Block_byref_a_0 a =
{
(void*)0.// isa
(__Block_byref_a_0 *)&a,// transfer of a address0.// flagssizeof(__Block_byref_a_0),// size0/ / a value
};
NSInteger b = 0;
((void (*)(id, SEL, void (^ _Nonnull)()))(void *)objc_msgSend)
((id)self, sel_registerName("setBlock111:"),
// initialize the __TestCode__testFunc_block_impl_0 structure
((void (*)())&__TestCode__testFunc_block_impl_0
(
(void *)__TestCode__testFunc_block_func_0,
&__TestCode__testFunc_block_desc_0_DATA,
b,// The value passes b
(__Block_byref_a_0 *)&a,// Pass in the address of structure (object) A570425344))); ((void (*(*)(id, SEL))())(void *)objc_msgSend)((id)self, sel_registerName("block111"())); }Copy the code
1. __Block_byref_a_0
struct __Block_byref_a_0 {void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
NSInteger a;
};
// Struct a is generated
__attribute__((__blocks__(byref))) __Block_byref_a_0 a =
{
(void*)0.// isa
(__Block_byref_a_0 *)&a,// transfer of a address0.// flagssizeof(__Block_byref_a_0),// size0/ / a value
};
Copy the code
With the__blockModification of thea, generated a use__attribute__Modification of the__Block_byref_a_0Type of structure.
There’s one inside the structureisaPointer, indicating__Block_byref_a_0Its essence is also aOCobject
2. The __TestCode__testFunc_block_impl_0 structure
struct __TestCode__testFunc_block_impl_0 {struct __block_implimpl;struct __TestCode__testFunc_block_desc_0* Desc;
NSInteger b;
__Block_byref_a_0 *a; // by ref// constructor with the same name
__TestCode__testFunc_block_impl_0
(
void *fp,
struct __TestCode__testFunc_block_desc_0 *desc,
NSInteger _b,
__Block_byref_a_0 *_a,
int flags=0) : b(_b), a(_a->__forwarding) { ... }};Copy the code
New properties are generated:
NSInteger b
_bisStack the b
bValue passed
__Block_byref_a_0 *a
Since the assignment to __TestCode__testFunc_block_impl_0 passes the address of __block_byref_a_0a in the stack area, _a == &a.
Since _a->__forwarding is &_a, a in __TestCode__testFunc_block_impl_0 refers to a in the stack
Conclusion:
blockIn thebAnd outside theb, only values are passed, so even if external modifications are madebThe value of theta is not going to be correctblockthebMake an impact.
__block a;theaPackaged into a structure, andblockInternal properties__Block_byref_a_0 *aThis is the stack structureaThe address of the
At this point,blockThere is nocopyOperation, soblockThere are stacks, structuresaThere is also a stack area
/** _Block_object_assign parameter flag Related // It is an object BLOCK_FIELD_IS_OBJECT = 3, // It is a block BLOCK_FIELD_IS_BLOCK = 7, // the __block variable BLOCK_FIELD_IS_BYREF = 8, Only secondary copy functions can use BLOCK_FIELD_IS_WEAK = 16, // block secondary function calls (telling internal implementations not to retain or copy) BLOCK_BYREF_CALLER = 128 **/void _Block_object_assign(void *destAddr, constvoid *object, constint flags) {
// BLOCK_BYREF_CALLER block auxiliary function call (telling internal implementation not to retain or copy)if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) {
//BLOCK_FIELD_IS_WEAK The __weak variable that can only be used by the auxiliary copy functionif ((flags & BLOCK_FIELD_IS_WEAK) == BLOCK_FIELD_IS_WEAK) {
_Block_assign_weak(object, destAddr);
}
else {
_Block_assign((void*)object, destAddr); }}// A variable modified by __blockelseif ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF) {
/// Finally go this way
_Block_byref_assign_copy(destAddr, object, flags);
}
// is a blockelseif((flags & BLOCK_FIELD_IS_BLOCK) == BLOCK_FIELD_IS_BLOCK) { _Block_assign(_Block_copy_internal(object, flags), destAddr); }// is an objectelseif ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) {
_Block_retain_object(object);
_Block_assign((void*)object, destAddr); }}Copy the code
structBlock_byref {void *isa;
structBlock_byref *forwarding;int flags; /* refcount; * /int size;
};
staticvoid _Block_byref_assign_copy(void *dest, constvoid *arg, constint flags) {
...
structBlock_byref *copy = (structBlock_byref*) _Block_allocator(src->size.false.isWeak);
copy->flags = src->flags | _Byref_flag_initial_value; // non-GC one for caller, one for stack// Copy forwarding in the heap points to itself
copy->forwarding = copy; // patch heap copy to point to itself (skip write-barrier)Forwarding in the stack refers to the new object in the heap
src->forwarding = copy; // patch stack to point to heap copycopy->size = src->size; .Destp = SRC ->forwarding = Block_byref *copy
_Block_assign(src->forwarding, (void **)destp);
}
Copy the code
As you can see, the first four members of Block_byref and __Block_byref_a_0 have the same type and can be converted to each other.
b. __TestCode__testFunc_block_dispose_0
// disposestaticvoid __TestCode__testFunc_block_dispose_0(struct __TestCode__testFunc_block_impl_0*src){
_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
}
Copy the code
_Block_object_dispose
void _Block_object_dispose(constvoid *object, constint flags) {
//printf("_Block_object_dispose(%p, %x)\n", object, flags);if (flags & BLOCK_FIELD_IS_BYREF) {
// Release the __block modified variable
_Block_byref_release(object);
}
elseif ((flags & (BLOCK_FIELD_IS_BLOCK|BLOCK_BYREF_CALLER)) == BLOCK_FIELD_IS_BLOCK) {
// Release the block referenced by the block
_Block_destroy(object);
}
elseif ((flags & (BLOCK_FIELD_IS_WEAK|BLOCK_FIELD_IS_BLOCK|BLOCK_BYREF_CALLER)) == BLOCK_FIELD_IS_OBJECT) {
// Release the object referenced by the block_Block_release_object(object); }}Copy the code
staticvoid _Block_byref_release(constvoid *arg) {
structBlock_byref *shared_struct = (structBlock_byref *)arg;int refcount;
shared_struct = shared_struct->forwarding;
if ((shared_struct->flags & BLOCK_NEEDS_FREE) == 0) {
return; // stack or GC or global
}
refcount = shared_struct->flags & BLOCK_REFCOUNT_MASK;
if (refcount <= 0) {
printf("_Block_byref_release: Block byref data structure at %p underflowed\n", arg);
}
elseif ((latching_decr_int(&shared_struct->flags) & BLOCK_REFCOUNT_MASK) == 0) {
if(shared_struct->flags & BLOCK_HAS_COPY_DISPOSE) { (*shared_struct->byref_destroy)(shared_struct); } _Block_deallocator((struct Block_layout *)shared_struct); }}staticvoid(*_Block_deallocator)(constvoid *)= (void(*) (constvoid *))free;
staticintlatching_decr_int(int *where){
while (1) {
int old_value = *(volatileint *)where;
if ((old_value & BLOCK_REFCOUNT_MASK) == BLOCK_REFCOUNT_MASK) {
return BLOCK_REFCOUNT_MASK;
}
if ((old_value & BLOCK_REFCOUNT_MASK) == 0) {
return0;
}
if (OSAtomicCompareAndSwapInt(old_value, old_value- 1, (volatileint *)where)) {
return old_value- 1; }}}Copy the code
A variable decorated with __block is released using latching_decr_int to subtract the reference count until the count reaches zero.
Normal objects, blocks, are destroyed.
Summary:
The copy desPose function is generated.
Copy call timing:
whenblockforcopyIt is called automatically when the operation is performed__TestCode__testFunc_block_desc_0The inside of the__TestCode__testFunc_block_copy_0The function,__TestCode__testFunc_block_copy_0The function is called internally_Block_object_assignFunction.
_Block_object_assignThe interior is based on passingflagsType toaforcopy,retainoperation
Despose call timing:
whenblockIt is called automatically when removed from the heap__TestCode__testFunc_block_desc_0In the__TestCode__testFunc_block_dispose_0The function,__TestCode__testFunc_block_dispose_0The function is called internally_Block_object_disposeFunction.
_Block_object_disposetoaDo a release operation, something like thatrelease.
4. __TestCode__testFunc_block_func_0
__TestCode__testFunc_block_func_0 is block code stored in the __block_impl structure
staticvoid __TestCode__testFunc_block_func_0(struct __TestCode__testFunc_block_impl_0 *__cself) {
__Block_byref_a_0 *a = __cself->a; // bound by ref
NSInteger b = __cself->b; // bound by copy
(a->__forwarding->a) = 12 + b;
printf("Block test code");
}
Copy the code
__cself is the block we define
A ->__forwarding actually changes our heap (Block_byref) copy.
The following figure shows a custom structure in testcode.m:
struct __Block_byref_a_0 { void *__isa; struct __Block_byref_a_0 *__forwarding; int __flags; int __size; NSInteger a; }; struct __block_impl { void *isa; &_nsConcretestAckBlock int Flags; int Reserved; void *FuncPtr; // The storage nature of the method is a __TestCode__testFunc_block_func_0 c function}; struct __TestCode__testFunc_block_impl_0 { struct __block_impl impl; struct __TestCode__testFunc_block_desc_0* Desc; struct __Block_byref_a_0 *a; // by ref };Copy the code
5. Chart
__block NSInteger a = 0; NSInteger b = 0; self.block111 = ^{ a = 12 + b; Printf (" Block test code "); };Copy the code
Holding object type
References to object types fall into three categories:
with__blockmodified
with__strongEmbellish (@strongify)
with__weakModify (@weakify)
⚠️ Note that the following code generates circular references, which will be examined in detail later
After self is decorated with a __block, blockPerson is wrapped into a structure similar to __Block_byref_a_0
There are only two more functions than __Block_byref_a_0:
__Block_byref_id_object_copyA value of__Block_byref_id_object_copy_131
__Block_byref_id_object_disposeA value of__Block_byref_id_object_dispose_131
⚠️ It is worth noting that blockSelf is decorated with __strong, thus creating circular references! __block Typeof (weakSelf)blockSelf = weakSelf; More on that below
__Block_byref_id_object_copy_131 and __Block_byref_id_object_dispose_131
struct __TestCode__testFunc_block_impl_0 {struct __block_implimpl;struct __TestCode__testFunc_block_desc_0* Desc;
__Block_byref_blockSelf1_0 *blockSelf1; // by ref
__Block_byref_blockSelf2_1 *blockSelf2; // by ref// Constructor of the same name__TestCode__testFunc_block_impl_0(...) {... }};struct __Block_byref_blockSelf1_0 {void *__isa;
__Block_byref_blockSelf1_0 *__forwarding;
int __flags;
int __size;
void (*__Block_byref_id_object_copy)(void*, void*);
void (*__Block_byref_id_object_dispose)(void*);
TestCode *__strong blockSelf1;
};
struct __Block_byref_blockSelf2_1 {void *__isa;
__Block_byref_blockSelf2_1 *__forwarding;
int __flags;
int __size;
void (*__Block_byref_id_object_copy)(void*, void*);
void (*__Block_byref_id_object_dispose)(void*);
typeof (weakSelf) blockSelf2;
};
Copy the code
Two member variables are generated in __TestCode__testFunc_block_impl_0
__block TestCode *blockSelf = weakSelf
TestCode *__strong blockSelf1; A strong reference is made to self, resulting in a +1 self reference count, resulting in a circular reference.
__block typeof(weakSelf)blockSelf2 = weakSelf;
Typeof (weakSelf) blockSelf2 Refers to self as a weak reference, and the reference count does not have +1 operation.
3. Added:
In the current scope, yesselftheretainCountPlus 1, minus 1 when out of scope
__block typeof(self)blockSelf = self;
__block NSObject *blockSelf = self;
__strong typeof (self)strongSelf = self;
__strong NSObject *strongSelf = self;
rightselftheretainCountDo not make operation
__weak typeof(self)weakSelf = self;
__weak NSObject *weakSelf = self;
Note:
Reference counts to objects with these modifier statements are valid only in the current scope. The key to having a block make a circular reference is this
Whether an object is strongly referenced in the __TestCode__testFunc_block_impl_0 block structure.
