英文歌曲_不可阻挡：block用法综述_沪江英语
分类学习站点
不可阻挡：block用法综述
编辑点评：本期主要讲的词汇是block，沪江词汇精选为大家挑选了高频词汇block，精讲了该词的不同词性，用法，意思，旨在帮助小伙伴们了解该词意思的同时，能够掌握同一词汇的不同用法，从而灵活运用所学词汇，最终达到提高英语素养的目标。
This&must&not&register&on&an&emotional&level.
First,&distract&target.
Then&block&his&blind&jab.
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& &&Sherlock&Holmes
这不得基于情感层面上。
首先，分清目标。
然后阻止他盲目击打。
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& &&《夏洛克福尔摩斯》
一、你知道block有几种含义吗？
The whole basin of water may be turned into a block of ice.
整盆水会变成一大块冰。
2.障碍物，阻碍 [C]
The government's stubborn attitude was a block to further talks.
政府的僵硬态度是进一步会谈的障碍。
3.街区 [C]
Head straight up the street about a block and then turn right.
顺着这条街一直走约一个街区，然后右转弯。
4.大楼，大厦 [C]
The students occupied the Administration Block.
学生占领了行政大楼。
1.阻塞 [T]
Two wrecks block the entrance to the harbour.
两艘船的残骸堵塞了通往港口的入口。
2.阻止；限制 [T]
Too much oxygen can also block regeneration.
过多的氧也可阻碍再生。
二、词义辨析：你知道还有哪些词表示&阻止&吗？
block, bar, hinder, obstruct, prevent, hamper
这些动词均含有&阻止、阻塞&之意。
block语气强烈，指有效堵住了通道，使人或物无法通过。
bar含义与block很接近，指阻塞通道或禁止出入，但有对暗示不用障碍物的阻止或禁止。
hinder语气较轻，多指阻碍、拖延人或事，强调使进展速度缓慢下来。
obstruct正式用词，语气强，多指以干扰或设置障碍的方式阻碍交通，使不能自由畅通。
prevent含义广泛，指采取预防措施或设置障碍去阻止某人或某事。
hamper侧重因受到约束或阻碍而造成的行动困难。
三、你知道block和哪些词更搭吗？
block letter
n.木板字,印刷体字母
堵住,阻住,隔开
v. 1. 遮住，挡住 2. 遮挡&使不被印出来 3. 画出&的略图；打草样；计划
v.阻碍,垫高
四，你学会block的用法了吗？一起来检测一下自己吧！
Note&that&the&resource&adapter&should&not_____ in&this&method.
注意，资源适配器不应当阻塞在这个方法中1463人阅读
一 &、Block的内存泄露体现
block在copy时都会对block内部用到的对象进行强引用(ARC)或者retainCount增1(非ARC)。在ARC与非ARC环境下对block使用不当都会引起循环引用问题。
一般表现为：
1.某个类将block作为自己的属性变量，然后该类在block的方法体里面又使用了该类本身，简单说就是
self.someBlock = ^(Type var){
[self dosomething];
self.otherVar = XXX;
或者_otherVar = ...
block的这种循环引用会被编译器捕捉到并及时提醒。（这个还是很人性化的，难道你不这么觉得吗？0.0）
& & &list：
//& Created by 58 on 15/6/3.
//& Copyright (c) 2015年 58. All rights reserved.
#import&TsetBlock.h&
void (^blockTest)(NSString
*str,NSString *st );
typedefvoid (^blockT)(NSString *str,NSString
@interfaceTsetBlock ()
@property (nonatomic)NSArray
@property (nonatomic ,copy)blockT
@implementation TsetBlock
-(id)init{
& &if (self = [superinit])
self.testArr =@[@&你&,@&觉&,@&的&,@&会&,@&怎&,@&样&];
& & & &&self.block = ^(NSString
*name,NSString *str){
& & & & & &NSLog(@&arr:%@&,self.testArr);
& &returnself;
那么问题来了：
网上大部分帖子都表述为&block里面引用了self导致循环引用&，但事实真的是如此吗？我表示怀疑，其实这种说法是不严谨的，不一定要显式地出现&self&字眼才会引起循环引用。我们改一下代码，不通过属性self.arr去访问arr变量，而是通过实例变量_arr去访问，如下：
很明显了：
即使在你的block代码中没有显式地出现&self&，也会出现循环引用！只要你在block里用到了self所拥有的东西！但对于这种情况，目前我不知道该如何排除掉循环引用，因为我们无法通过加__weak声明或者__block声明去禁止block对self进行强引用或者强制增加引用计数。对于self.arr的情况，我们要分两种环境去解决：
&__weaktypeof(self)
weakSelf= 其实 __weak someClass *weakSelf = self也是OK的！！！
2.MRC:解决方式与上述基本一致，只不过将__weak关键字换成__block即可，这样的意思是告诉block：孙子，咱们已经没有关系了（不要在内部对self进行retain了）！
&二、正确的使用BLOCK避免cycle&retain
&&我们一起来看看,经Clang编译后的block结构
struct Block_literal_1 {
void (*invoke)(void *, ...);
struct Block_descriptor_1 {
unsigned long int
unsigned long int
// optional helper functions
void (*copy_helper)(void *dst, void *src);
// IFF (1&&25)
void (*dispose_helper)(void *src);
// IFF (1&&25)
// required ABI.
const char *
// IFF (1&&30)
// imported variables
1.Block执行的代码，这是在编译的时候已经生成好的；
2.一个包含Block执行时需要的所有外部变量值的数据结构。
Block将使用到的、作用域附近到的变量的值建立一份快照拷贝到栈上。
Block与函数另一个不同是，Block类似ObjC的对象，可以使用自动释放池管理内存（但Block并不完全等同于ObjC对象，后面将详细说明）。
关于Block的基本语法就不在陈述，相信都已经滚瓜烂熟了
（1）block在内存中的位置
& & & & &根据Block在内存中的位置分为三种类型NSGlobalBlock，NSStackBlock, NSMallocBlock。
&1&NSGlobalBlock：类似函数，位于text段；
&2&NSStackBlock：位于栈内存，函数返回后Block将无效；
&3&NSMallocBlock：位于堆内存。
& & & & &可以看到在Block结构体中含有isa指针，这就证明了Block其实就是对象，并具有一般对象的所有功能。这个isa指针被初始化为_NSConcreteStackBlock或者_NSConcreteGlobalBlock类的地址。在没有开启ARC的情况下，如果Block中包含有局部变量则isa被初始化为前者，否则就被初始化为后者。而当ARC开启后，如果Block中包含有局部变量则isa被初始化为_NSConcreteMallocBlock，否则就被初始化为_NSConcreteGlobalBlock。invoke是一个函数指针，它指向的是Block被转换成函数的地址。最后的imported
variables部分是Block需要访问的外部的局部变量，他们在编译就会被拷贝到Block中，这样一来Block就是成为一个闭包了。
& & &代码LIST：
& &1& &&blockT blk1 = & ^&int(int a,
& & & & & &return a+
& & & & };
(lldb)po blk1
&__NSGlobalBlock__: 0x102b54080&
& & 2& & &int base =100;
blockT blk2 = & ^ int(int a,int b) {
& & & & & &
return base +a+
& & & & };
(lldb)po blk2
&__NSStackBlock__: 0x7fff5d0abab0&
& & &3& &&blockT blk3 = [[blk2copy]
autorelease];
(lldb)po blk3
&__NSMallocBlock__: 0x7f89aa6854f0&
在Block内变量base是只读的，如果想在Block内改变base的值，在定义base时要用&__block修饰
&Block的copy、retain、release操作
1) Block_copy与copy等效，Block_release与release等效；
2) 对Block不管是retain、copy、release都不会改变引用计数retainCount，retainCount始终是1；
& & & &&3)&NSGlobalBlock：retain、copy、release操作都无效；
4)&NSStackBlock：retain、release操作无效，必须注意的是，NSStackBlock在函数返回后，Block内存将被回收。即使retain也没用。容易犯的错误是[[mutableAarry
addObject:stackBlock]，在函数出栈后，从mutableAarry中取到的stackBlock已经被回收，变成了野指针。正确的做法是先将stackBlock copy到堆上，然后加入数组：[mutableAarry
addObject:[[stackBlock copy] autorelease]]。支持copy，copy之后生成新的NSMallocBlock类型对象。
5)NSMallocBlock支持retain、release，虽然retainCount始终是1，但内存管理器中仍然会增加、减少计数。copy之后不会生成新的对象，只是增加了一次引用，类似retain；
6)&尽量不要对Block使用retain操作。
retain cycle
retain cycle问题的根源在于Block和obj可能会互相强引用，互相retain对方，这样就导致了retain cycle，最后这个Block和obj就变成了孤岛，谁也释放不了谁。
ASIHTTPRequest*request=[ASIHTTPRequestrequestWithURL:url];
[requestsetCompletionBlock:^{&
NSString*string=
[requestresponseString];
要想打破循环可以 &__block&ASIHTTPRequest*request=[ASIHTTPRequestrequestWithURL:url];
request被持有者释放后。request
的retainCount变成0,request被dealloc，request释放持有的Block，导致Block的retainCount变成0，也被销毁。这样这两个对象内存都被回收。
retain cycle不只发生在两个对象之间，也可能发生在多个对象之间，这样问题更复杂，更难发现
ClassA* objA = [[[ClassA alloc] init] autorelease];
objA.myBlock = ^{
[self doSomething];
self.objA = objA;
+-----------+
+-----------+
+-----------+
| --------& |
| --------& |
| retain 1
| retain 1
| retain 1
+-----------+
+-----------+
+-----------+
+------------------------------------------------+
解决办法同样是用__block打破循环引用
ClassA* objA = [[[ClassA alloc] init] autorelease];
MyClass* weakSelf = self;
objA.myBlock = ^{
[weakSelf doSomething];
self.objA = objA;
注意：MRC中__block是不会引起retain；但在ARC中__block则会引起retain。ARC中应该使用__weak或__unsafe_unretained弱引用。__weak只能在iOS5以后使用。
Block使用对象被提前释放
看下面例子，有这种情况，如果不只是request持有了Block，另一个对象也持有了Block。
+-----------+
+-----------+
| --------& |
|&--------
| retain 1
| & - - - - | retain 2
+-----------+
+-----------+
这时如果request 被持有者释放。
+-----------+
+-----------+
| --------& |
|&--------
| retain 0
| & - - - - | retain 1
+-----------+
+-----------+
这时request已被完全释放，但Block仍被objA持有，没有释放，如果这时触发了Block，在Block中将访问已经销毁的request，这将导致程序crash。为了避免这种情况，开发者必须要注意对象和Block的生命周期。
另一个常见错误使用是，开发者担心retain cycle错误的使用__block。比如
__block kkProducView* weakSelf = self;
dispatch_async(dispatch_get_main_queue(), ^{
weakSelf.xx = xx;
将Block作为参数传给dispatch_async时，系统会将Block拷贝到堆上，如果Block中使用了实例变量，还将retain self，因为dispatch_async并不知道self会在什么时候被释放，为了确保系统调度执行Block中的任务时self没有被意外释放掉，dispatch_async必须自己retain一次self，任务完成后再release
self。但这里使用__block，使dispatch_async没有增加self的引用计数，这使得在系统在调度执行Block之前，self可能已被销毁，但系统并不知道这个情况，导致Block被调度执行时self已经被释放导致crash。
// MyClass.m
- (void) test {
__block MyClass* weakSelf = self;
double delayInSeconds = 10.0;
dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
NSLog(@&%@&, weakSelf);
// other.m
MyClass* obj = [[[MyClass alloc] init] autorelease];
[obj test];
这里用dispatch_after模拟了一个异步任务，10秒后执行Block。但执行Block的时候MyClass*
obj已经被释放了，导致crash。解决办法是不要使用__block。
&&相关文章推荐
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：13679次
排名：千里之外
原创：24篇
评论：10条
(1)(1)(1)(1)(2)(1)(3)(10)(6)对于block的理解及用法的注意 - 博客频道 - CSDN.NET
ThatBoys的博客
对于block的理解及用法的注意
Block跟swift中的闭包（closure）比较:
基本一样,都常用于值的回调,特别是在多线程网络请求回调中,使用起来极为方便.
Block:格式:
block的开头是&^&,接着是由小括号所包起来的参数列,行为主体由大括号包起来.block有四种类型,分别是无参无返回,无参有返回,有参有返回,以及有参无返回.而一般的block是有参block,因为使用block主要就是进行参数的传递.
Block的循环引用问题:
使用block时要特别注意类的循环引用:例如在一个控制器中,self强指针指向一个对象,而这个对象又强指针指向一个block,而在block中,又强指针指向了self,从而导致循环引用,导致内存无法释放,造成内存泄漏.
解决循环引用的方法:
解决循环引用block的方法,常用__weak来打断强引用,例如用__weak来定义一个weakself来指向self的地址,如果self被释放,weakself指向的地址变为nil,从而打断引用环.需要注意的是,__weak是ARC专有的,__unsafe __unretained可以用在ARC 也可以用在MRC,但是__unsadfe __retained是&assign&形式,如果是指向对象被释放,其指针地址保持不变,如果继续使用该指针,就会出现&野指针&.
关于block的内存管理:
当block内部没有引用外部变量,block存放在全局区;在MRC下,当block内部引用外部变量,block存放在栈区;当对该栈区的block进行copy操作时,block将存放在堆区.在ARC下,当block内部引用外部变量时,block存放在堆区;关于堆区和栈区的区别,栈区主要存放局部变量,定义的参数等,在函数结束,系统会自定回收其内存空间,而堆区一般程序员自行分配释放,若程序员不释放,程序结束时,由系统回收.总的来说,使用栈区更为快捷,而使用堆区更为灵活.
Block使用的注意点:
如果要在block中修改外部变量,当变量是static全局变量时,block可以直接修饰,如果不是,可以使用__block关键字来修饰,就可以在block内修改变量的值.
排名：千里之外3175人阅读
iOS-移动开发（41）
Objective-C中的block有多种定义和使用方法.
作为property
@property (nonatomic, copy) int (^myBlock)(int a, int b);
block代码体:
_myBlock = ^int (int a, int b) {
return a +
sum = _myBlock(10, 20);
使用typedef
typedef int (^MyBlock)(int a, int b);
MyBlock myBlock = ^int (int a, int b) {
return a *
int sum = myBlock(10, 20);
int (^myBlock) (int a, int b) = ^int (int a, int b) {
return a -
int sum = myBlock(10, 20);
此时myBlock可作为变量自由传递, 调用的时候myBlock(10, 20);即可.
如果想在block中对当前局部变量进行修改的话, 需要使用__block:
__block int sum = 0;
int (^myBlock)(int a, int b) = ^int (int a, int b) {
return sum;
block默认可访问局部变量sum, 而不能修改, 以防出现循环引用的情况.
而__block对象在block中不会被其强引用一次, 所以不会出现循环引用.
__block与__weak
以上可知, 声明block的时候只是把该sum局部变量复制了一份, 因此若其是一个指针, 则在block中修改其指向的内容不需要加__block.
__block修饰对象和基本数据类型, 而__weak只能修饰对象.
__block对象可在block中修改(重新赋值), 而__weak不行.
因此, 对于类的对象, 若要在block中对其属性进行修改, 需要使用__weak. 如:
__weak MyClass *weakSelf =
_myBlock2 = ^(NSInteger count) {
weakSelf.count = count;
作为方法调用的参数
预先声明MyBlock及属性myBlock2,
typedef int (^MyBlock)(int a, int b);
@property (nonatomic, copy) MyBlock myBlock2;
定义方法methodTakeBlock接收MyBlock.
- (int)methodTakeBlock:(MyBlock)block {
int sum = 0;
if (block) {
sum = block(10, 20);
return sum;
则调用该方法的时候, 在其参数中实现该MyBlock实体:
sum = [self methodTakeBlock:^int (int a, int b) {
return b /
这种方式仅在implementation中即可.
在方法的声明中写明block类型
在interface中:
- (int)method2TakeBlock:(int (^) (int a, int b))
在implementation中:
- (int)method2TakeBlock:(int (^)(int, int))block {
int sum = 0;
if (block) {
sum = block(10, 20);
return sum;
sum = [self method2TakeBlock:^int(int a, int b) {
return a * b -
在ViewController之间传递数据
在TestViewController.h中定义一个block, 用于从TestViewController跳转至ViewController时修改ViewController中的label内容:
#import &UIKit/UIKit.h&
@interface TestViewController : UIViewController
typedef void(^BlockUpdateBtnTitle)(NSString *);
@property (nonatomic, copy) BlockUpdateBtnTitle blockUpdateBtnT
该block接收一个NSString参数.
点击button触发以下动作
- (IBAction)action:(UIButton *)sender {
if (_blockUpdateBtnTitle) {
_blockUpdateBtnTitle(@"value changed by block");
[self dismissViewControllerAnimated:NO completion:nil];
在ViewController.m中传递block实体, 注意其接收参数要与定义的一致:
- (IBAction)action:(UIButton *)sender {
TestViewController *testVC = [[TestViewController alloc] init];
__weak ViewController *weakSelf = self;
testVC.blockUpdateBtnTitle = ^(NSString *btnTitle) {
weakSelf.lb.text = btnT
[self presentViewController:testVC animated:NO completion:nil];
点击button跳转至TestViewController中, 在TestViewController中执行该blockUpdateBtnTitle, 进而修改ViewController中label的内容.
因在block中要对ViewController中的属性进行修改, 因此可使用__weak来防止循环引用.
&&相关文章推荐
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：208488次
积分：3249
积分：3249
排名：第9608名
原创：117篇
转载：22篇
评论：28条
文章：65篇
阅读：118423
(1)(2)(7)(6)(1)(4)(3)(5)(5)(13)(3)(19)(11)(6)(12)(5)(7)(8)(4)(8)(8)(1)(2)