我們在使用block的時候，如果在block中使用self有可能會迴圈引用，產生記憶體洩漏的問題。

通常，我們如果遇到這種情況，我們會將self轉換成weak automatic的變數，這樣就避免了block對self強引用，即：

__weak typeof(self) weakSelf = self;
__weak __typeof__(self) weakSelf = self;
__weak __typeof(self) weakSelf = self;

以上三種寫法，任選一種都是可以的，typeof就是獲取變數的型別，沒別的深奧的東西。

但是，我在檢視AFNetworking原始碼的時候發現發現，在有的block中使用self

為此，我做了相關的測試。講道理，如果存在記憶體洩漏，那麼dealloc方法就不會被呼叫。

測試一：

@property (copy, nonatomic) dispatch_block_t testBlock;

- (void)viewDidLoad {
    [super viewDidLoad];

    self.testBlock = ^(){
        NSLog(@"%@", [self class]);
    };
    self.testBlock();
}

這塊我為了簡單，直接使用GCD

typedef void (^dispatch_block_t)(void)

它是一個無引數，無返回值的block。
這個testBlock是控制器（以下用VC代替）的一個屬性。在block中直接使用self就會造成迴圈引用，Xcode也會做出相應的警告提示：

⚠️ Capturing self strongly in this block is likely to lead to a retain cycle.

這句話的意思就是說，此處的block強引用了self，會存在保留環，即迴圈引用，那麼VC的dealloc方法也不會被正常呼叫。這個時候我們就需要將其轉化為weakSelf

- (void)viewDidLoad {
    [super viewDidLoad];

    __weak typeof(self) weakSelf = self;

    self.testBlock = ^(){
        NSLog(@"%@", [weakSelf class]);
    };
    self.testBlock();
}

這樣VC的dealloc方法也可以正常被呼叫了。

結論：當block直接做為VC的屬性時，如果block內部沒有使用weakSelf，則會造成迴圈引用，導致記憶體洩漏。

測試二：

- (void)viewDidLoad {
    [super viewDidLoad];

    __weak typeof(self) weakSelf = self;

    self.testBlock = ^(){
        [weakSelf doSomething];
    };
    self.testBlock();
}

- (void)doSomething {
    NSLog(@"%@", [self class]);
}

測試發現VC的dealloc方法被正常呼叫。

結論：當在block中呼叫一個方法，並且這個方法中直接或者間接的使用self，不會出現記憶體洩漏的問題。

測試三：

- (void)viewDidLoad {
    [super viewDidLoad];

    dispatch_block_t block = ^(){
        [self doSomething];
    };
    block();
}

- (void)doSomething {
    NSLog(@"%@", [self class]);
}

測試發現VC的dealloc方法被正常呼叫，所以我們在使用GCD的時候，大部分情況都不需要做轉換。

結論：當block不是self的屬性時，block記憶體使用self不會造成記憶體洩漏的問題。

測試四：

- (void)viewDidLoad {
    [super viewDidLoad];

    Class VC = self.class;
    [VC doSomethingWithBlock:^{
        [self doSomething];
    }];
}

+ (void)doSomethingWithBlock:(dispatch_block_t)block {
    if (block) {
        block();
    }
}

- (void)doSomething {
    NSLog(@"%@", [self class]);
}

測試發現VC的dealloc方法被正常呼叫，我們在使用UIView有關動畫的類方法時，大部分情況都不需要做轉換。

結論：當使用類方法，並且類方法中用block做引數時，block內部使用self也不會造成記憶體洩漏的問題。

通過這麼多的測試，我們可以看到，當且僅當block直接或間接的被self持有時，如果不做weakSelf轉換，就會有記憶體洩漏的風險。

最後補充一點，同樣在檢視AFNetworking的時候，遇到有時候還需要轉化成strongSelf的情況：

 __weak __typeof(self) weakSelf = self;

NSURLSessionDataTask *dataTask = nil;
dataTask = [self.sessionManager GET:request.URL.absoluteString parameters:nil progress:nil success:^(NSURLSessionDataTask * _Nonnull task, id  _Nullable responseObject) {
        __strong __typeof(weakSelf) strongSelf = weakSelf;
        sf_dispatch_main_async_safely(^{
            if (success) {
                success((NSHTTPURLResponse *)task.response, responseObject);
            }
            [strongSelf loadData:responseObject MIMEType:MIMEType textEncodingName:textEncodingName baseURL:task.currentRequest.URL];
            if ([strongSelf.delegate respondsToSelector:@selector(webViewDidStartLoad:)]) {
                [strongSelf.delegate webViewDidFinishLoad:strongSelf];
            }
        });
    } failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
        sf_dispatch_main_async_safely(^{
            if (failure) {
                failure(error);
            }
        });
  }];

那麼什麼情況下，需要將weakSelf轉化成strongSelf呢 ？

由於__weak變數的特殊性，會在物件銷燬後自動置為nil，如果在block中多次需要訪問self，就需要轉化為strong automatic，確保在block使用期間，self不會被釋放。