OC：深刻探究 block

主要分析了block在持有__block、__weak、__strong修飾的對象時，block結構發生的變化。

以及block對持有變量的引用計數形成的具體影響。

思考：

@implementation TestCode
- (void)testFunc {
    @weakify(self)
    self.block111 = ^{
        @strongify(self);
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            if (self) {
                printf("\n\nstrongPerson1 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
            }else{
                printf("self Retain Count = 0 \n");
            }
        });
    };
}

- (void)dealloc {
    printf("\n");
    printf("✅ 【dealloc】 Retain Count = 0");
}
@end

  
@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    TestCode *t = [[TestCode alloc]init];
    [t testFunc];
  	
    if (t.block111) {
        t.block111();
    }
}
@end
複製代碼

注意: 如下block111是self所持有的block

• 若是在block111 中對 NSMutableArray *arrayM 進行增刪元素, arrayM是否須要用__block修飾？

• 在block111 中對weakSelf進行 __strong typeof(weakSelf) strongSelf = weakSelf 修飾

  • 若是block一直不調用，那麼self是否能夠正常銷燬？
  • 當運行到__strong typeof(weakSelf) strongSelf = weakSelf的下一行時，self引用計數最少是多少？

一：基本介紹

定義

Block 是帶有自動變量(局部變量)的匿名函數， 是 C 語言的擴充功能，其本質是一個OC對象。

1. 做爲屬性

   @property (nonatomic,copy) void(^block)(void);

2. 做爲參數

   - (void) getDataWithBlock:(id(^)(id parameter))block;

3. 做爲返回值(masonry)

   - (MASConstraint * (^)(id))equalTo

結構

- (void)testFunc {
    self.block111 = ^{
        printf("block測試代碼");
    };
    self.block111();
}
複製代碼

把OC代碼轉成c++代碼

clang -x objective-c -rewrite-objc -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk -fobjc-arc -fobjc-runtime=macosx-10.13 xxxxxx.m

static void _I_TestCode_testFunc(TestCode * self, SEL _cmd) {
    /// self.block = &__TestCode__testFunc_block_impl_0(A,B)
    ((void (*)(id, SEL, void (^ _Nonnull)()))(void *)objc_msgSend)
     ((id)self, sel_registerName("setBlock111:"),
      (
       (void (*)())&__TestCode__testFunc_block_impl_0
        (
         (void *)__TestCode__testFunc_block_func_0,// 參數1
         &__TestCode__testFunc_block_desc_0_DATA// 參數2__TestCode__testFunc_block_desc_0,
        )
       )
     );
    
    ((void (*(*)(id, SEL))())(void *)objc_msgSend)((id)self, sel_registerName("block111"))();
}
複製代碼

上段代碼的基本意思是

1. self.block = &__TestCode__testFunc_block_impl_0(A,B)

   1. A: __TestCode__testFunc_block_func_0
   2. B: __TestCode__testFunc_block_desc_0_DATA

1. __TestCode__testFunc_block_impl_0

struct __TestCode__testFunc_block_impl_0 {
  
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_0* Desc;
  
  __TestCode__testFunc_block_impl_0(void *fp, struct __TestCode__testFunc_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
複製代碼

命名規律：__類名__方法名_block_impl_層級

上述代碼中能夠看出block 被編譯成了__TestCode__testFunc_block_impl_0結構體

1. 其內部有一個同名的構造函數__TestCode__testFunc_block_impl_0
2. 兩個屬性

   1. __block_impl impl

   2. __TestCode__testFunc_block_desc_0* Desc

2. __block_impl

struct __block_impl {
  void *isa;// 指向了&_NSConcreteStackBlock
  int Flags;
  int Reserved;
  void *FuncPtr; // 用於方法的儲存本質是一個 __TestCode__testFunc_block_func_0 c函數
};
複製代碼

能夠發現__block_impl結構體內部就有一個isa指針。所以能夠證實block本質上就是一個oc對象。

__block_impl結構體中isa指針存儲着&_NSConcreteStackBlock地址，能夠暫時理解爲其類對象地址，block就是_NSConcreteStackBlock類型的。

1. 看到isa就會聯想到以前在objc_class結構體，所以咱們的block本質上也是一個對象【並且是個類對象】 咱們知道實例對象->類對象->元類構成了isa鏈中的一條，而這個__block_impl結構體佔據的是中間類對象的位置
2. 這裏的isa指針會指向元類，這裏的元類主要是爲了說明這個塊的存儲區域

__TestCode__testFunc_block_func_0

static void __TestCode__testFunc_block_func_0(struct __TestCode__testFunc_block_impl_0 *__cself) {
        printf("block測試代碼");
}
複製代碼

__TestCode__testFunc_block_func_0 中存放的是block中的代碼

3. __TestCode__testFunc_block_desc_0

static struct __TestCode__testFunc_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __TestCode__testFunc_block_desc_0_DATA = { 0, sizeof(struct __TestCode__testFunc_block_impl_0)};
複製代碼

主要是存儲了block的大小

4. 同名的構造函數__TestCode__testFunc_block_impl_0(void *fp, struct __TestCode__testFunc_block_desc_0 *desc, int flags=0)

__TestCode__testFunc_block_impl_0
    (void *fp, struct __TestCode__testFunc_block_desc_0 *desc, int flags=0)
    {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
複製代碼

同名函數主要對兩個屬性進行了賦值

• void *fp 就是 (void *)__TestCode__testFunc_block_func_0__
• __ struct __TestCode__testFunc_block_desc_0 *desc 就是 &__TestCode__testFunc_block_desc_0_DATA

5. 結構圖

二：持有變量時block的結構

以上分析的是 block 不持有任何外部變量，可是當block持有外部變量的時候，就會額外生成一些東西。

持有基本數據類型

持有的基本數據類型分爲是否用__block修飾，以下，a 用__block修飾，b沒有。

- (void)testFunc {
    __block NSInteger a = 0;
    NSInteger b = 0;
    self.block111 = ^{
        a = 12 + b;
        printf("block測試代碼");
    };
    self.block111();
}
複製代碼

思考

a用__block修飾後能夠修改，必然a從值傳遞，變成了地址傳遞。

1. __blok把a封裝成了什麼結構？
2. 結構a的值到底存在哪裏？
3. 結構a是怎麼管理內存的？

要回答上述問題，咱們須要查看- (void)testFunc{}編譯的源碼：

編譯後:

static void _I_TestCode_testFunc(TestCode * self, SEL _cmd) {
	// 結構體 a 的生成 (__block NSInteger a = 0;)
    __attribute__((__blocks__(byref))) __Block_byref_a_0 a =
    {
        (void*)0, // isa
        (__Block_byref_a_0 *)&a,// a地址的傳遞
        0,// flags
        sizeof(__Block_byref_a_0),// size
        0// a的值
    };
    
    NSInteger b = 0;
    
    ((void (*)(id, SEL, void (^ _Nonnull)()))(void *)objc_msgSend)
    ((id)self, sel_registerName("setBlock111:"),
     
     /// 初始化__TestCode__testFunc_block_impl_0結構體
     ((void (*)())&__TestCode__testFunc_block_impl_0
      (
       (void *)__TestCode__testFunc_block_func_0,
       &__TestCode__testFunc_block_desc_0_DATA,
       
       b,//值傳遞b
       (__Block_byref_a_0 *)&a,//把結構體（對象）a的地址傳了進去
       
       570425344
       ))
     );
    
    ((void (*(*)(id, SEL))())(void *)objc_msgSend)((id)self, sel_registerName("block111"))();
}
複製代碼

1. __Block_byref_a_0

struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 NSInteger a;
};

// 結構體 a 的生成 
    __attribute__((__blocks__(byref))) __Block_byref_a_0 a =
    {
        (void*)0, // isa
        (__Block_byref_a_0 *)&a,// a地址的傳遞
        0,// flags
        sizeof(__Block_byref_a_0),// size
        0// a的值
    };
複製代碼

• 用了__block修飾的a，生成了一個用__attribute__ 修飾的 __Block_byref_a_0類型的結構體。
• 結構體內部有一個isa指針,說明__Block_byref_a_0其本質也是一個OC對象

2. __TestCode__testFunc_block_impl_0結構體

struct __TestCode__testFunc_block_impl_0 {
    
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_0* Desc;
    
  NSInteger b;
  __Block_byref_a_0 *a; // by ref
    
  // 同名的構造函數
  __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) { ... }
};
複製代碼

生成了新的屬性:

• NSInteger b

  • _b就是棧區的b
  • b 值傳遞

• __Block_byref_a_0 *a

  • 因爲賦值到__TestCode__testFunc_block_impl_0時，傳遞的是 棧區的__Block_byref_a_0 a的地址,因此 _a == &a。

  • 由於_a->__forwarding就是&_a所以__TestCode__testFunc_block_impl_0結構體中的a指向的就是棧中的a

小結論:

1. block中的b和外部的b,只是值傳遞，所以即使外部修改了b的值，也不會對block的b產生影響。
2. __block a;把a包裝成了一個結構體,而block內部屬性__Block_byref_a_0 *a就是棧區結構體a的地址
3. 此時， block沒有copy操做，因此block存在棧區，結構體a也存在棧區

3. __TestCode__testFunc_block_desc_0

static struct __TestCode__testFunc_block_desc_0 {
  size_t reserved;
  size_t Block_size;
   //copy 函數
  void (*copy)(
    struct __TestCode__testFunc_block_impl_0*, 
    struct __TestCode__testFunc_block_impl_0*
  );
  // dispose 函數
  void (*dispose)(struct __TestCode__testFunc_block_impl_0*);
    
} __TestCode__testFunc_block_desc_0_DATA = 
																	{ 0,// reserved
                                   sizeof(struct __TestCode__testFunc_block_impl_0), //size
                                   __TestCode__testFunc_block_copy_0,//copy
                                   __TestCode__testFunc_block_dispose_0//dispose
                                   };
複製代碼

生成了 copy dispose 函數

a. __TestCode__testFunc_block_copy_0

1. block被拷貝到堆區的時候調用

2. 實現函數是 _Block_object_assign，它根據對象的 flags 來判斷是否須要拷貝，或者只是賦值。

// copy
static void __TestCode__testFunc_block_copy_0(struct __TestCode__testFunc_block_impl_0*dst, struct __TestCode__testFunc_block_impl_0*src){
  _Block_object_assign(
                        (void*)&dst->a, 
			(void*)src->a,
			8/*BLOCK_FIELD_IS_BYREF*/
                        );
}
複製代碼

_Block_object_assign

函數實如今 runtime.c 裏

/** _Block_object_assign參數flag相關 // 是一個對象 BLOCK_FIELD_IS_OBJECT = 3, // 是一個block BLOCK_FIELD_IS_BLOCK = 7, // 被__block修飾的變量 BLOCK_FIELD_IS_BYREF = 8, // 被__weak修飾的變量，只能被輔助copy函數使用 BLOCK_FIELD_IS_WEAK = 16, // block輔助函數調用（告訴內部實現不要進行retain或者copy） BLOCK_BYREF_CALLER = 128 **/

void _Block_object_assign(void *destAddr, const void *object, const int flags) {
  
  // BLOCK_BYREF_CALLER block輔助函數調用（告訴內部實現不要進行retain或者copy）
    if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) {
      
      //BLOCK_FIELD_IS_WEAK 被__weak修飾的變量，只能被輔助copy函數使用 
        if ((flags & BLOCK_FIELD_IS_WEAK) == BLOCK_FIELD_IS_WEAK) {
            _Block_assign_weak(object, destAddr);
        }
        else {
            _Block_assign((void *)object, destAddr);
        }
    }
  
  // 被__block修飾的變量
    else if ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF)  {
      ///最終走到這邊 
        _Block_byref_assign_copy(destAddr, object, flags);
    }
  
  // 是一個block
    else if ((flags & BLOCK_FIELD_IS_BLOCK) == BLOCK_FIELD_IS_BLOCK) {
        _Block_assign(_Block_copy_internal(object, flags), destAddr);
    }
  
  // 是一個對象
    else if ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) {
        _Block_retain_object(object);
        _Block_assign((void *)object, destAddr);
    }
}
複製代碼

/* Block_private.h https://opensource.apple.com/source/libclosure/libclosure-73/Block_private.h */
 enum {
        BLOCK_DEALLOCATING =      (0x0001),  // runtime
        BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
        BLOCK_NEEDS_FREE =        (1 << 24), // runtime
        BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
        BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
        BLOCK_IS_GC =             (1 << 27), // runtime
        BLOCK_IS_GLOBAL =         (1 << 28), // compiler
        BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
        BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler
        BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler
    };

struct Block_byref {
    void *isa;
    struct Block_byref *forwarding;
    int flags; /* refcount; */
    int size;
};


/** runtime.c http://llvm.org/svn/llvm-project/compiler-rt/trunk/lib/BlocksRuntime/runtime.c */
static void *_Block_copy_class = _NSConcreteMallocBlock;
static void *_Block_copy_finalizing_class = _NSConcreteMallocBlock;
static int _Block_copy_flag = BLOCK_NEEDS_FREE;
static int _Byref_flag_initial_value = BLOCK_NEEDS_FREE | 2;

static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {

  	struct Block_byref **destp = (struct Block_byref **)dest;
    struct Block_byref *src = (struct Block_byref *)arg;

		//不須要作任何操做
    if (src->forwarding->flags & BLOCK_IS_GC) {
    }
  
		// 須要copy到堆區 而且須要操做引用計數
    else if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // src points to stack
        bool isWeak = ((flags & (BLOCK_FIELD_IS_BYREF|BLOCK_FIELD_IS_WEAK)) == (BLOCK_FIELD_IS_BYREF|BLOCK_FIELD_IS_WEAK));
        // if its weak ask for an object (only matters under GC)
        struct Block_byref *copy = (struct Block_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 = copy; // patch heap copy to point to itself (skip write-barrier)
        src->forwarding = copy;  // patch stack to point to heap copy
        copy->size = src->size;
        if (isWeak) {
            copy->isa = &_NSConcreteWeakBlockVariable;  // mark isa field so it gets weak scanning
        }
        if (src->flags & BLOCK_HAS_COPY_DISPOSE) {
            // Trust copy helper to copy everything of interest
            // If more than one field shows up in a byref block this is wrong XXX
            copy->byref_keep = src->byref_keep;
            copy->byref_destroy = src->byref_destroy;
            (*src->byref_keep)(copy, src);
        }
        else {
            // just bits. Blast 'em using _Block_memmove in case they're __strong
            _Block_memmove(
                (void *)&copy->byref_keep,
                (void *)&src->byref_keep,
                src->size - sizeof(struct Block_byref_header));
        }
    }
    // 已經複製到堆、只操做引用計數
    else if ((src->forwarding->flags & BLOCK_NEEDS_FREE) == BLOCK_NEEDS_FREE) {
        latching_incr_int(&src->forwarding->flags);
    }
    // assign byref data block pointer into new Block
  	// 其實進行了 *destp = src->forwarding 操做，把棧區的a，變成了 Block_byref *copy
    _Block_assign(src->forwarding, (void **)destp);
}

static void (*_Block_assign)(void *value, void **destptr) = _Block_assign_default;

static void _Block_assign_default(void *value, void **destptr) {
    *destptr = value;
}
複製代碼

省略後的代碼

struct Block_byref {
    void *isa;
    struct Block_byref *forwarding;
    int flags; /* refcount; */
    int size;
};

static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {
    ...
    struct Block_byref *copy = (struct Block_byref *)_Block_allocator(src->size, false, isWeak);
    copy->flags = src->flags | _Byref_flag_initial_value; // non-GC one for caller, one for stack
    // 堆中拷貝的forwarding指向它本身
    copy->forwarding = copy; // patch heap copy to point to itself (skip write-barrier)
    // 棧中的forwarding指向堆中的新對象
    src->forwarding = copy;  // patch stack to point to heap copy
    copy->size = src->size;
    ...
     // 其實進行了 *destp = src->forwarding 操做，把棧區的a，變成了 Block_byref *copy
    _Block_assign(src->forwarding, (void **)destp);
}
複製代碼

能夠看到，Block_byref 和 __Block_byref_a_0 的前4個成員類型相同，能夠互相轉化。

b. __TestCode__testFunc_block_dispose_0

// dispose
static void __TestCode__testFunc_block_dispose_0(struct __TestCode__testFunc_block_impl_0*src){
_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
}
複製代碼

_Block_object_dispose

void _Block_object_dispose(const void *object, const int flags) {
    //printf("_Block_object_dispose(%p, %x)\n", object, flags);
    if (flags & BLOCK_FIELD_IS_BYREF)  {
      // 釋放 __block 修飾的變量
        _Block_byref_release(object);
    }
    else if ((flags & (BLOCK_FIELD_IS_BLOCK|BLOCK_BYREF_CALLER)) == BLOCK_FIELD_IS_BLOCK) {
				// 釋放block 引用的 block
        _Block_destroy(object);
    }
    else if ((flags & (BLOCK_FIELD_IS_WEAK|BLOCK_FIELD_IS_BLOCK|BLOCK_BYREF_CALLER)) == BLOCK_FIELD_IS_OBJECT) {
        // 釋放block 引用的對象
        _Block_release_object(object);
    }
}
複製代碼

static void _Block_byref_release(const void *arg) {
    struct Block_byref *shared_struct = (struct Block_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);
    }
    else if ((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);
    }
}

static void (*_Block_deallocator)(const void *) = (void (*)(const void *))free;

static int latching_decr_int(int *where) {
    while (1) {
        int old_value = *(volatile int *)where;
        if ((old_value & BLOCK_REFCOUNT_MASK) == BLOCK_REFCOUNT_MASK) {
            return BLOCK_REFCOUNT_MASK;
        }
        if ((old_value & BLOCK_REFCOUNT_MASK) == 0) {
            return 0;
        }
        if (OSAtomicCompareAndSwapInt(old_value, old_value-1, (volatile int *)where)) {
            return old_value-1;
        }
    }
}
複製代碼

被__block修飾的變量，釋放時要用 latching_decr_int函數減引用計數，直到計數爲0，就釋放該對象；

而普通的對象、block，就直接釋放銷燬。

小結：

1. 生成了copy despose函數。

2. copy 調用時機：

   1. 當block進行copy操做的時候就會自動調用__TestCode__testFunc_block_desc_0內部的__TestCode__testFunc_block_copy_0函數，__TestCode__testFunc_block_copy_0函數內部會調用_Block_object_assign函數。
   2. _Block_object_assign內部是根據傳遞的flags類型來對a進行copy、retain操做

3. despose 調用時機：

   1. 當block從堆中移除時就會自動調用__TestCode__testFunc_block_desc_0中__TestCode__testFunc_block_dispose_0函數，__TestCode__testFunc_block_dispose_0函數內部會調用_Block_object_dispose函數。
   2. _Block_object_dispose會對 a作釋放操做，相似於release。

4. __TestCode__testFunc_block_func_0

__TestCode__testFunc_block_func_0是__block_impl結構體中存儲的block代碼

static void __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測試代碼");
}
複製代碼

__cself就是咱們定義的block

a->__forwarding其實修改的就是咱們堆區的(Block_byref) copy (注意 在ARC下咱們的block會自動copy)

下圖在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; // 用於方法的儲存本質是一個 __TestCode__testFunc_block_func_0 c函數
};
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
};
複製代碼

5. 結構圖

__block NSInteger a = 0;
NSInteger b = 0;
self.block111 = ^{
	a = 12 + b;
	printf("block測試代碼");
};
複製代碼

持有對象類型

對象類型的引用分爲三種狀況：

1. 用 __block 修飾
2. 用__strong 修飾（@strongify）
3. 用__weak 修飾 （@weakify）

⚠️注意下面的代碼產生了循環引用，隨後會作詳細的分析

- (void)testFunc {
    
    __weak typeof(self)weakSelf = self;
    __block TestCode *blockSelf = weakSelf;
    
    self.block111 = ^{
        __strong typeof(weakSelf)strongSelf = weakSelf;
        void(^block222)(void) = ^{
            blockSelf = strongSelf;
            printf("\nblock測試代碼\n");
        };
        block222();
    };
    
    self.block111();
}
複製代碼

編譯上述代碼：

static void _I_TestCode_testFunc(TestCode * self, SEL _cmd) {

    __attribute__((objc_ownership(weak))) typeof(self)weakSelf = self;
    __attribute__((__blocks__(byref))) __Block_byref_blockSelf_0 blockSelf =
    {
        (void*)0,
        (__Block_byref_blockSelf_0 *)&blockSelf,
        33554432,
        sizeof(__Block_byref_blockSelf_0),
        __Block_byref_id_object_copy_131,
        __Block_byref_id_object_dispose_131,
        weakSelf
    };

    // 建立 __TestCode__testFunc_block_impl_1
    ((void (*)(id, SEL, void (^ _Nonnull)()))(void *)objc_msgSend)((id)self, sel_registerName("setBlock111:"), ((void (*)())&__TestCode__testFunc_block_impl_1
     (//參數：
      (void *)__TestCode__testFunc_block_func_1,
      &__TestCode__testFunc_block_desc_1_DATA,
      weakSelf,
      (__Block_byref_blockSelf_0 *)&blockSelf,
      570425344)
      ));

    ((void (*(*)(id, SEL))())(void *)objc_msgSend)((id)self, sel_registerName("block111"))();
}
複製代碼

1. __Block_byref_blockSelf_0

struct __Block_byref_blockSelf_0 {
  //【值爲：0】[8個字節]
  void *__isa;
  //【值爲&blockSelf】,[8個字節]
__Block_byref_blockSelf_0 *__forwarding;
  
 int __flags;//【值爲33554432】,[4個字節]
 int __size;//【值爲sizeof(__Block_byref_blockSelf_0)】,[4個字節]
  
  //【__Block_byref_id_object_copy_131】[8個字節]
 void (*__Block_byref_id_object_copy)(void*, void*);
  //【__Block_byref_id_object_dispose_131】,[8個字節]
 void (*__Block_byref_id_object_dispose)(void*);
  
 TestCode *__strong blockSelf;//【weakSelf】[8個字節]
};
/// 共48個字節
複製代碼

self使用__block修飾後，blockPerson 被包裝成了一個與__Block_byref_a_0類似的結構體

只是比__Block_byref_a_0多了兩個函數：

1. __Block_byref_id_object_copy值爲__Block_byref_id_object_copy_131
2. __Block_byref_id_object_dispose值爲__Block_byref_id_object_dispose_131

⚠️值得注意的是blockSelf用了__strong修飾，所以產生了循環引用！須要改爲__block typeof(weakSelf)blockSelf = weakSelf; 下面會有詳細解釋

__Block_byref_id_object_copy_131 與 __Block_byref_id_object_dispose_131

static void __Block_byref_id_object_copy_131(void *dst, void *src) {
 _Block_object_assign((char*)dst + 40, *(void * ) ((char)src + 40), 131);
}
static void __Block_byref_id_object_dispose_131(void *src) {
 _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}
複製代碼

內部調用函數爲_Block_object_assign

dst與src就是blockSelf即__Block_byref_blockSelf_0結構體指針

因__Block_byref_blockSelf_0共48個字節，因此(char*)dst + 40 與(char)src + 40，找到的就是TestCode *__strong blockSelf

最後的flags傳遞的是131 = 3|128 即 ： BLOCK_FIELD_IS_OBJECT|BLOCK_FIELD_IS_CALLER

調用時機：block執行copy操做，後面會詳細分析。

2. __TestCode__testFunc_block_impl_1

struct __TestCode__testFunc_block_impl_1 {
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_1* Desc;
    
  TestCode *const __weak weakSelf;
  __Block_byref_blockSelf_0 *blockSelf; // by ref
    
  __TestCode__testFunc_block_impl_1(
                                    void *fp,
                                    struct __TestCode__testFunc_block_desc_1 *desc,
                                    TestCode *const __weak _weakSelf,
                                    __Block_byref_blockSelf_0 *_blockSelf,
                                    int flags=0
                                    ) : weakSelf(_weakSelf), blockSelf(_blockSelf->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

複製代碼

生成了兩個成員變量：Person *__weak weakPerson;、__Block_byref_blockPerson_0 *blockPerson;

**a. __block_impl impl **

結構沒有任何變化

1. flags: 570425344表示BLOCK_HAS_COPY_DISPOSE | BLOCK_HAS_DESCRIPTOR，即（1<<25 | 1<<29）
2. FuncPtr: __TestCode__testFunc_block_func_1

3. __TestCode__testFunc_block_desc_1

結構沒有任何變化

desc:結構體__TestCode__testFunc_block_desc_1_DATA

static struct __TestCode__testFunc_block_desc_1 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __TestCode__testFunc_block_impl_1*, struct __TestCode__testFunc_block_impl_1*);
  void (*dispose)(struct __TestCode__testFunc_block_impl_1*);
} __TestCode__testFunc_block_desc_1_DATA = {
    0,
    sizeof(struct __TestCode__testFunc_block_impl_1),
    __TestCode__testFunc_block_copy_1,
    __TestCode__testFunc_block_dispose_1
};
複製代碼

值得注意的是：copy、dispose的實現函數

// copy 函數
static void __TestCode__testFunc_block_copy_1(struct __TestCode__testFunc_block_impl_1*dst, struct __TestCode__testFunc_block_impl_1*src)
{
    _Block_object_assign((void*)&dst->weakSelf, (void*)src->weakSelf, 3/*BLOCK_FIELD_IS_OBJECT*/);
    _Block_object_assign((void*)&dst->blockSelf, (void*)src->blockSelf, 8/*BLOCK_FIELD_IS_BYREF*/);
}

// dispose 函數
static void __TestCode__testFunc_block_dispose_1(struct __TestCode__testFunc_block_impl_1*src)
{
    _Block_object_dispose((void*)src->weakSelf, 3/*BLOCK_FIELD_IS_OBJECT*/);
    _Block_object_dispose((void*)src->blockSelf, 8/*BLOCK_FIELD_IS_BYREF*/);
}
複製代碼

a. 對weakSelf 的 _Block_object_assign操做

void _Block_object_assign(void *destAddr, const void *object, const int flags) {
  
  // BLOCK_BYREF_CALLER block輔助函數調用（告訴內部實現不要進行retain或者copy）
    if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) { ... }
  // 被__block修飾的變量
    else if ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF)  { ... }
  // 是一個block
    else if ((flags & BLOCK_FIELD_IS_BLOCK) == BLOCK_FIELD_IS_BLOCK) { ... }
  
  // 是一個對象
    else if ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) {
        _Block_retain_object(object);
        _Block_assign((void *)object, destAddr);
    }
}
複製代碼

即直接對對象進行一個_Block_retain_object操做

可是發如今ARC下_Block_retain_object函數並無給對象的引用計數+1。

static void (*_Block_retain_object)(const void *ptr) = _Block_retain_object_default;
static void _Block_retain_object_default(const void *ptr) {
    if (!ptr) return;
}
複製代碼

b. 對blockSelf的_Block_object_assign操做

最終會調用到_Block_byref_assign_copy函數

static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {

  	struct Block_byref **destp = (struct Block_byref **)dest;
    struct Block_byref *src = (struct Block_byref *)arg;

		//不須要作任何操做
    if (src->forwarding->flags & BLOCK_IS_GC) {
    }
  
		// 須要copy到堆區 而且須要操做引用計數
    else if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        bool isWeak = ((flags & (BLOCK_FIELD_IS_BYREF|BLOCK_FIELD_IS_WEAK)) == (BLOCK_FIELD_IS_BYREF|BLOCK_FIELD_IS_WEAK));
      
        struct Block_byref *copy = (struct Block_byref *)_Block_allocator(src->size, false, isWeak);
        copy->flags = src->flags | _Byref_flag_initial_value;
        copy->forwarding = copy; 
        src->forwarding = copy;  
        copy->size = src->size;
      
        if (isWeak) {
            copy->isa = &_NSConcreteWeakBlockVariable;  
        }
        if (src->flags & BLOCK_HAS_COPY_DISPOSE) {
          /// 調用 __Block_byref_blockSelf_0 中的 __Block_byref_id_object_copy 函數
					/// 執行byref的byref_keep函數(即assign函數，只是會加上BLOCK_BYREF_CALLER標誌)，管理捕獲的對象內存
            copy->byref_keep = src->byref_keep;
            copy->byref_destroy = src->byref_destroy;
            (*src->byref_keep)(copy, src);
        }
        else { ... }
    }
    // 已經複製到堆、只操做引用計數
    else if ((src->forwarding->flags & BLOCK_NEEDS_FREE) == BLOCK_NEEDS_FREE) { ... }
    _Block_assign(src->forwarding, (void **)destp);
}
複製代碼

值得注意的是在Block_private.h找到了這個結構：

struct Block_byref {
    void *isa;
    struct Block_byref *forwarding;
    volatile int32_t flags; // contains ref count
    uint32_t size;
};

struct Block_byref_2 {
    // requires BLOCK_BYREF_HAS_COPY_DISPOSE
    BlockByrefKeepFunction byref_keep;
    BlockByrefDestroyFunction byref_destroy;
};

struct Block_byref_3 {
    // requires BLOCK_BYREF_LAYOUT_EXTENDED
    const char *layout;
};

複製代碼

其實byref_keep就是blockSelf中的__Block_byref_id_object_copy也就是函數__Block_byref_id_object_copy_131

因此其調用爲

static void __Block_byref_id_object_copy_131(void *dst, void *src) {
 _Block_object_assign((char*)dst + 40, *(void * ) ((char)src + 40), 131);
}
  // 譯爲
static void __Block_byref_id_object_copy_131(__Block_byref_blockSelf_0 *dst, __Block_byref_blockSelf_0 *src) {
 _Block_object_assign(
   dst->blockSelf, 
   *(void * )(src->blockSelf), 
   BLOCK_FIELD_IS_OBJECT|BLOCK_FIELD_IS_CALLER
 );
}
複製代碼

繼續看_Block_object_assign

void _Block_object_assign(void *destAddr, const void *object, const int flags) {
  
  // BLOCK_BYREF_CALLER block輔助函數調用（告訴內部實現不要進行retain或者copy）
    if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) {
      //BLOCK_FIELD_IS_WEAK 被__weak修飾的變量，只能被輔助copy函數使用 
        if ((flags & BLOCK_FIELD_IS_WEAK) == BLOCK_FIELD_IS_WEAK) {
            _Block_assign_weak(object, destAddr);
        }
        else {
            _Block_assign((void *)object, destAddr);
        }
    }
    else if ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF)  { ... }
    else if ((flags & BLOCK_FIELD_IS_BLOCK) == BLOCK_FIELD_IS_BLOCK) { ... }
    else if ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) { ... }
}
static void (*_Block_assign)(void *value, void **destptr) = _Block_assign_default;

static void _Block_assign_default(void *value, void **destptr) {
    *destptr = value;
}
複製代碼

運行了_Block_assign函數，把棧區的__Block_byref_blockSelf_0 blockSelf賦值成了Block_byref copy

c. 對weakSelf 的 dispose操做

static void __TestCode__testFunc_block_dispose_1(struct __TestCode__testFunc_block_impl_1*src) 
{
  _Block_object_dispose(
    (void*)src->self, 
    3/*BLOCK_FIELD_IS_OBJECT*/
  );
  _Block_object_dispose(
    (void*)src->blockSelf,
    8/*BLOCK_FIELD_IS_BYREF*/
  );
}

void _Block_object_dispose(const void *object, const int flags) {
    if (flags & BLOCK_FIELD_IS_BYREF)  { ... }
    else if ((flags & (BLOCK_FIELD_IS_BLOCK|BLOCK_BYREF_CALLER)) == BLOCK_FIELD_IS_BLOCK) {...}
    else if ((flags & (BLOCK_FIELD_IS_WEAK|BLOCK_FIELD_IS_BLOCK|BLOCK_BYREF_CALLER)) == BLOCK_FIELD_IS_OBJECT) {
        // 釋放block 引用的對象
        _Block_release_object(object);
    }
}
static void (*_Block_release_object)(const void *ptr) = _Block_release_object_default;
static void _Block_release_object_default(const void *ptr) {
    if (!ptr) return;
}
複製代碼

能夠看到：最終會調用到_Block_release_object,內部也是沒對引用計數進行操做。

d. 對blockSelf 的 dispose操做

其最終走到了_Block_byref_release函數：

static void _Block_byref_release(const void *arg) {
    struct Block_byref *shared_struct = (struct Block_byref *)arg;
    int refcount;
    shared_struct = shared_struct->forwarding;
    if ((shared_struct->flags & BLOCK_NEEDS_FREE) == 0) {
        return; 
    }
    refcount = shared_struct->flags & BLOCK_REFCOUNT_MASK;
    if (refcount <= 0) {  }
    else if ((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);
    }
}

複製代碼

其中__block_release函數內部主要是調用了(*shared_struct->byref_destroy)(shared_struct)

也就是 __Block_byref_blockSelf_0 *blockSelf 中的__Block_byref_id_object_dispose_131函數

static void __Block_byref_id_object_dispose_131(void *src) {
	 _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}

///譯爲：
static void __Block_byref_id_object_dispose_131(__Block_byref_blockSelf_0 *src) {
	
  _Block_object_dispose
   (
     *(void * *) (src->blockSelf), 
     BLOCK_FIELD_IS_OBJECT|BLOCK_FIELD_IS_CALLER
   );
}
複製代碼

e. __TestCode__testFunc_block_func_1

查看__TestCode__testFunc_block_func_1，函數中是如何建立第二層block222的

{
  __strong typeof(weakSelf)strongSelf = weakSelf;
        void(^block222)(void) = ^{
            blockSelf = strongSelf;
            printf("\nblock測試代碼\n");
        };
        block222();
}

static void __TestCode__testFunc_block_func_1(struct __TestCode__testFunc_block_impl_1 *__cself) {
    
    __Block_byref_blockSelf_0 *blockSelf = __cself->blockSelf; // bound by ref
    TestCode *const __weak weakSelf = __cself->weakSelf; // bound by copy

    ///__strong typeof(weakSelf)strongSelf = weakSelf;
    __attribute__((objc_ownership(strong))) typeof(weakSelf)strongSelf = weakSelf;
    
    /// 建立block222 即：__TestCode__testFunc_block_impl_0結構體
    void(*block222)(void) = ((void (*)())&__TestCode__testFunc_block_impl_0((void *)__TestCode__testFunc_block_func_0,&__TestCode__testFunc_block_desc_0_DATA,strongSelf,(__Block_byref_blockSelf_0 *)blockSelf,570425344));
  
    /// 調用: block222()
    ((void (*)(__block_impl *))((__block_impl *)block222)->FuncPtr)((__block_impl *)block222);
}
複製代碼

其中block222是一個__TestCode__testFunc_block_impl_0結構體

4. __TestCode__testFunc_block_impl_0

struct __TestCode__testFunc_block_impl_0 {
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_0* Desc;
    
  TestCode *const __strong strongSelf;
  __Block_byref_blockSelf_0 *blockSelf; // by ref
    
  __TestCode__testFunc_block_impl_0(
                                    void *fp,
                                    struct __TestCode__testFunc_block_desc_0 *desc,
                                    TestCode *const __strong _strongSelf,
                                    __Block_byref_blockSelf_0 *_blockSelf,
                                    int flags=0
                                    ) : strongSelf(_strongSelf), blockSelf(_blockSelf->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
複製代碼

其結構和__TestCode__testFunc_block_impl_1結構類似。

只不過blockSelf就是上層block（即：block111）中的 blockSelf

值得注意的是這邊有個TestCode *const __strong strongSelf;

剩下的結構與以前分析的結構大同小異：

static void __TestCode__testFunc_block_func_0(struct __TestCode__testFunc_block_impl_0 *__cself) {
  __Block_byref_blockSelf_0 *blockSelf = __cself->blockSelf; // bound by ref
  TestCode *const __strong strongSelf = __cself->strongSelf; // bound by copy

            (blockSelf->__forwarding->blockSelf) = strongSelf;
            printf("\nblock測試代碼\n");
        }
static void __TestCode__testFunc_block_copy_0(struct __TestCode__testFunc_block_impl_0*dst, struct __TestCode__testFunc_block_impl_0*src) {_Block_object_assign((void*)&dst->blockSelf, (void*)src->blockSelf, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_assign((void*)&dst->strongSelf, (void*)src->strongSelf, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __TestCode__testFunc_block_dispose_0(struct __TestCode__testFunc_block_impl_0*src) {_Block_object_dispose((void*)src->blockSelf, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_dispose((void*)src->strongSelf, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static struct __TestCode__testFunc_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __TestCode__testFunc_block_impl_0*, struct __TestCode__testFunc_block_impl_0*);
  void (*dispose)(struct __TestCode__testFunc_block_impl_0*);
} __TestCode__testFunc_block_desc_0_DATA = { 0, sizeof(struct __TestCode__testFunc_block_impl_0), __TestCode__testFunc_block_copy_0, __TestCode__testFunc_block_dispose_0};
複製代碼

三：持有變量引用計數操做：

既然在ARC 下copy、dispose函數都沒有對引用計數作修改，那麼何時會對引用計數進行操做?

經過對持有變量的分析、能夠總結出如下特色

1. 用__strong 與 __weak修飾

- (void)testFunc {
    printf("\n Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    __weak typeof (self)weakSelf1 = self;
    printf("\n 【__weak typeof (self)weakSelf】 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    __weak TestCode *weakSelf2 = self;
    printf("\n 【__weak TestCode *weakSelf2】 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    __strong typeof(self)strongSelf1 = self;
    printf("\n 【__strong typeof(self)strongSelf1】 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    __strong TestCode *strongSelf2 = self;
    printf("\n 【__strong TestCode *strongSelf2】 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    self.block111 = ^{
        [weakSelf1 class];
        [weakSelf2 class];
        [strongSelf1 class];
        [strongSelf2 class];
    };
}

/** log:
 Retain Count = 1
 【__weak typeof (self)weakSelf】 Retain Count = 1
 【__weak TestCode *weakSelf2】 Retain Count = 1
 【__strong typeof(self)strongSelf1】 Retain Count = 2
 【__strong TestCode *strongSelf2】 Retain Count = 3
*/
複製代碼

編譯後的代碼：

static void _I_TestCode_testFunc(TestCode * self, SEL _cmd) {
    printf("...");
    
	  __attribute__((objc_ownership(weak))) typeof (self)weakSelf1 = self;	
    __attribute__((objc_ownership(weak))) TestCode *weakSelf2 = self;
  
    __attribute__((objc_ownership(strong))) typeof(self)strongSelf1 = self;
    __attribute__((objc_ownership(strong))) TestCode *strongSelf2 = self;

    ((void (*)(id, SEL, void (^ _Nonnull)()))(void *)objc_msgSend)((id)self, sel_registerName("setBlock111:"), ((void (*)())&__TestCode__testFunc_block_impl_0((void *)__TestCode__testFunc_block_func_0, &__TestCode__testFunc_block_desc_0_DATA, strongSelf1, strongSelf2, 570425344)));
}


struct __TestCode__testFunc_block_impl_0 {
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_0* Desc;
 
  TestCode *const __weak weakSelf1;
  TestCode *__weak weakSelf2;
  
  __strong typeof (self) strongSelf1;
  TestCode *__strong strongSelf2;

  // 同名構造函數
  __TestCode__testFunc_block_impl_0(...){ ... }
};

複製代碼

1. __weak

   __weak TestCode *weakSelf1 = self與__weak typeof(self)weakSelf2 = self

   最終都調用了__attribute__((objc_ownership(weak)))

   並且__TestCode__testFunc_block_impl_0中對weakSelf1和weakSelf2都是弱引用

2. __strong

   __strong typeof(self)strongSelf1 = self與__strong TestCode *strongSelf2 = self

   最終都調用了__attribute__((objc_ownership(strong)))

   並且__TestCode__testFunc_block_impl_0中對strongSelf1和strongSelf2都是強引用

2. 用__block修飾的對象

用__block修飾的對象分紅兩種寫法

1. __block TestCode *blockSelf = weakSelf
2. __block typeof(weakSelf)blockSelf2 = weakSelf

- (void)testFunc {
    printf("\n Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    __weak typeof(self)weakSelf = self;
    
    __block TestCode *blockSelf1 = weakSelf;
    printf("\n 【__block TestCode *blockSelf1 = weakSelf】 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    __block typeof(weakSelf)blockSelf2 = weakSelf;
    printf("\n 【__block typeof(weakSelf)blockSelf2 = weakSelf】 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
    
    self.block111 = ^{
        [blockSelf1 class];
        [blockSelf2 class];
    };
}

/**log: Retain Count = 1 【__block TestCode *blockSelf1 = weakSelf】 Retain Count = 2 【__block typeof(weakSelf)blockSelf2 = weakSelf】 Retain Count = 2 */
複製代碼

編譯上述代碼：

struct __TestCode__testFunc_block_impl_0 {
  
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_0* Desc;
    
  __Block_byref_blockSelf1_0 *blockSelf1; // by ref
  __Block_byref_blockSelf2_1 *blockSelf2; // by ref
  
    // 同名構造函數
  __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;
};

複製代碼

在__TestCode__testFunc_block_impl_0中生成了兩個成員變量

1. __block TestCode *blockSelf = weakSelf

   TestCode *__strong blockSelf1;對self進行了強引用，從而self引用計數+1,從而產生循環引用。

2. __block typeof(weakSelf)blockSelf2 = weakSelf;

   typeof (weakSelf) blockSelf2 對self的引用爲弱引用，引用計數沒有+1操做。

3. 補充：

1. 在當前做用域中，對self的retainCount加1，退出做用域後減一
   1. __block typeof(self)blockSelf = self;
   2. __block NSObject *blockSelf = self;
   3. __strong typeof (self)strongSelf = self;
   4. __strong NSObject *strongSelf = self;
2. 對self的retainCount不做操做
   1. __weak typeof(self)weakSelf = self;
   2. __weak NSObject *weakSelf = self;

注意 :

用這些修飾語句對對象的引用計數只在當前做用域有效。讓block產生循環引用的關鍵在於

__TestCode__testFunc_block_impl_0 block結構體中對對象是不是強引用。

思考答案

@implementation TestCode
- (void)testFunc {
    @weakify(self)
    self.block111 = ^{
        @strongify(self);
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            if (self) {
                printf("\n\nstrongPerson1 Retain Count = %ld",CFGetRetainCount((__bridge CFTypeRef)(self)));
            }else{
                printf("self Retain Count = 0 \n");
            }
        });
    };
}

- (void)dealloc {
    printf("\n");
    printf("✅ 【dealloc】 Retain Count = 0");
}
@end
複製代碼

編譯後代碼：

/// block111結構體
struct __TestCode__testFunc_block_impl_1 {
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_1* Desc;
  
  TestCode *const __weak self_weak_;// 若引用
  
  __TestCode__testFunc_block_impl_1(void *fp, struct __TestCode__testFunc_block_desc_1 *desc, TestCode *const __weak _self_weak_, int flags=0) : self_weak_(_self_weak_) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

///block111中儲存的代碼
static void __TestCode__testFunc_block_func_1(struct __TestCode__testFunc_block_impl_1 *__cself) {
  TestCode *const __weak self_weak_ = __cself->self_weak_; // bound by copy

        try {} catch (...) {}
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshadow"
 __attribute__((objc_ownership(strong))) __typeof__(self) self = self_weak_;
#pragma clang diagnostic pop
;
        dispatch_after(dispatch_time((0ull), (int64_t)(2.0 * 1000000000ull)), dispatch_get_main_queue(), ((void (*)())&__TestCode__testFunc_block_impl_0((void *)__TestCode__testFunc_block_func_0, &__TestCode__testFunc_block_desc_0_DATA, self, 570425344)));
    }


/// block222結構體
struct __TestCode__testFunc_block_impl_0 {
    
  struct __block_impl impl;
  struct __TestCode__testFunc_block_desc_0* Desc;
    
  __strong typeof (self) self;/// 強引用
    
  __TestCode__testFunc_block_impl_0(void *fp, struct __TestCode__testFunc_block_desc_0 *desc, __strong typeof (self) _self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
複製代碼

**注意：**如下block111是self所持有的block

• 若是在block111 中對 NSMutableArray *arrayM 進行增刪元素, arrayM是否須要用__block修飾？

  答：不須要，由於並無修改arrayM指針所指向的地址

• 在block111 中對weakSelf進行 __strong typeof(weakSelf) strongSelf = weakSelf 修飾

  • 若是block一直不調用，那麼self是否能夠正常銷燬？

    答：能夠銷燬

    由於block調用的時候，纔會建立__TestCode__testFunc_block_impl_0

    使得__TestCode__testFunc_block_impl_0內部對self進行了強引用

    從而只要__TestCode__testFunc_block_impl_0不銷燬，self就沒法銷燬

  • 當運行到__strong typeof(weakSelf) strongSelf = weakSelf的下一行時，self引用計數最少是多少？

    答：最少是2

    可是出了__strong typeof(weakSelf) strongSelf = weakSelf的做用域，self的引用計數就會自動減1

參考文章

1. 探索 Block 的本質
2. iOS底層原理總結 - 探尋block的本質（一）
3. iOS底層原理總結 - 探尋block的本質（二）
4. iOS Block Part6:block拷貝的實現
5. OS - Block底層解析
6. 一篇文章剖析block底層源碼以及Block.private
7. Block_private.h
8. runtime.c

若是有不對的地方歡迎來噴~

郵箱：15076299703@163.com