//不可变字符串为例
- (void)setName:(NSString*)name{
	if (_name != name){
		[_name release];
		_name = [name copy];//浅拷贝，指针拷贝，指向同一块数据，保持数据唯一性。
	}
}
//可变字符串为例
- (void)setName:(NSMutalbeString*)name{
	if (_name != name){
		[_name release];
		_name = [name copy];//深拷贝，内容拷贝，生成新的对象，且_name的类型变为不可变类型(NSString)。
	}
}

//不可变字符串为例
- (void)setName:(NSString*)name{
	if (_name != name){
		[_name release];
		_name = [name retain];//深拷贝，内容拷贝，生成新的不可变对象。
	}
}
//可变字符串为例
- (void)setName:(NSMutalbeString*)name{
	if (_name != name){
		[_name release];
		_name = [name retain];//深拷贝，内容拷贝，生成新的可变对象。
	}
}

                一旦系统内存过低，iOS会通知所有运行中app。如果你的app收到了内存警告，它就需要尽可能释放更多的内存。最佳的方式是移除缓存。 幸运的是，UIKit的提供了集中收集内存警告的方法：（1）在appdelegate中使用applicationDidReceiveMemoryWarning：的方法 （2）在你自定义UIViewController的子类中覆盖didReceiveMemoryWarning （3）注册并接受 UIApplicationDidReceiveMemoryWarningNotification的通知，一旦接受到通知你就需要释放任何不必要的内存使用。

                一些objects的初始化很慢，比如NSDateFormatter 和NSCalendar。然而你又不可避免的使用它们，比如从JSON和XML中解析数据。想要避免使用这个对象的瓶颈你就需要重用它们，可以通过添加属性到你的class里或者创建静态变量来实现。如果你选用第二种方式，对象会在你的app运行时一直存在于内存中（存在于静态区），和单例很相似。 注意：设置一个NSDateFormatter的速度差不多和创建新的一样慢

                UIWebView很有用，用它来展示网页内容或者创建UIKit很难做到的动画效果是很简单的一件事。 但是你可能有注意到UIWebView并不像驱动Safari的那么快，这个由于以JIT compilation为特色的Webkit的Nitro Engine的限制。所以想要更高的性能你就要调整你的HTML了。第一件要做的事就是尽可能移除不必要的javascript，避免使用过大的框架。只能用原生js就更好了。 另外，尽可能异步加载例如用户行为统计script这种不影响页面表达的javascript。 最后，永远要注意你使用的图片，保证图片的符合你使用的大小。使用Sprite sheet提高加载速度和节约内存

               为了保证TableVIew有更好的滚动性能，可以采取以下措施： （1）正确使用ruseIdentifier来重用cells。（2）采用懒加载即延迟加载的方式加载cell上的控件。（3）当TableView滑动的时候不加载（这个我会在接下的文章中写具体的代码实现）（4）缓存cell的高度。在呈现cell前，把cell的高度计算好缓存起来，避免每次加载cell的时候都要计算。（5）尽量使用不透明的UI控件（6）使用drawRect绘制

               NSAutoreleasePool负责释放block中autoreleased objects。一般情况下它会自动被UIKit调用。但是有些状况下你也需要手动去创建它。假如你创建很多临时对象，你会发现内存一直在减少直到这些对象被release的时候。这是因为只有当UIKit用光了autorelease Pool的时候Memory才会被释放。好消息是你自己可以创建临时的autorelease对象来避免这个行为

                常见的从bundle中加载图片的方式有两种，一个是imageNamed，另一个时imageWithContentOfFile。既然有两种方式那它们之间有什么差别呢？先说第一种方式他的优点是当加载是它会缓存图片。相反imageWithContentOfFile的仅仅加载图片。如果你加载一个大的图片而且仅仅使用一次的话就没必要缓存图片

       调用方式：

              +load方法是通过函数地址，来调用。

              +initialize方法是通过objc_msgSend(消息发送机制)来调用。

     调用时刻：

             +load方法是在runtime时，加载类/分类时被调用，每个类/分类在程序运行过程中只调用一次。

             +initialize方法是在类第一次收到消息时调用，在程序运行过程中，如果该类没有收到消息，那么+initialize方法也不会被调用。

    category调用顺序：

            +load方法

                   先调用类的+load方法。先编译的类，优先调用+load方法；调用子类的+load方法之前，会先调用父类的+load方法。

                   再调用分类的+load方法。先编译的分类，优先调用+load方法。

     +initialize方法

                  先调用父类的+initialize方法。(父类的+initialize方法可能最终被多次调用)

                 再调用子类的+initialize方法。(类的+initialize方法，可以被分类覆盖)

 NSInvocation;在主线程中创建方法,则在主线程中执行;在分线程中创建方法,则在分线程中执行;


               NSBlockOperation;会自动查找空闲的线程进行使用;

//暂停 YES
//只能暂停当前操作后面的操作，要等待当前操作完成后，才能暂停。
[queue setSuspended:YES];
//恢复 NO
[queue setSuspended:NO];
//取消
//只能取消等待中的操作，当前的操作无法取消。
[queue cancelAllOperations];

//获取主队列
dispatch_queue_t main_queue = dispatch_get_main_queue();

//获取全局队列
    dispatch_queue_t global_queue = dispatch_get_global_queue(0, 0);

//串行队列，同步执行
- (void)sync_serial_queue {
    for (int i = 0; i < 20; i++) {
        dispatch_sync(self.serial_queue, ^{
            NSLog(@"%d===%@",i,[NSThread currentThread]);
        });
    }
}

//串行队列，异步执行
- (void)async_serial_queue {
    for (int i = 0; i < 20; i++) {
        dispatch_async(self.serial_queue, ^{
            NSLog(@"%d===%@",i,[NSThread currentThread]);
        });
    }
}

//并行队列，同步执行
- (void)sync_concurrent_queue {
    for (int i = 0; i < 20; i++) {
        dispatch_sync(self.concurrent_queue, ^{
            NSLog(@"%d===%@",i,[NSThread currentThread]);
        });
    }
}

//并行队列，异步执行
- (void)async_concurrent_queue {
    for (int i = 0; i < 20; i++) {
        dispatch_async(self.concurrent_queue, ^{
            NSLog(@"%d===%@",i,[NSThread currentThread]);
        });
    }
}

- (void)dispatch_after {
    NSLog(@"%@",[NSDate date]);
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"after == %@",[NSDate date]);
    });
}

- (void)dispatch_once {
    for (int i = 0; i < 10; i++) {
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            NSLog(@"%d",i);
        });
    }
}

- (void)dispatch_apply {
    dispatch_apply(10, self.concurrent_queue, ^(size_t index) {
        NSLog(@"dispatch_apply==%zud===%@",index,[NSThread currentThread]);
    });
}

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, queue, ^{
        
        NSLog(@"任务一完成");
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"任务二完成");
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"任务三完成");
    });
     //所有的分组中必须是同步操作,如果是异步的话就没有作用(例如:网络请求)
    //在分组的所有任务完成后触发
    dispatch_group_notify(group, queue, ^{
        NSLog(@"所有任务完成");
    });

- (void)barrier {
//    dispatch_queue_t queue = dispatch_queue_create("com.lai.www", DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t queue =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
    
    dispatch_async(queue, ^{
        NSLog(@"任务1-1完成");
    });
    dispatch_async(queue, ^{
        NSLog(@"任务1-2完成");
    });
    
    dispatch_async(queue, ^{
        NSLog(@"任务1-3完成");
    });
    //内部执行的是同步操作没有问题，如果以上三个任务都是异步的，比如是网络请求，那么就达不到我们想要的效果。因为异步，请求没有回来，dispatch_group_notify或者dispatch_barrier_async已经执行了

    dispatch_barrier_async(queue, ^{
        NSLog(@"以上任务都完成 dispatch_barrie完成");
    });
}

          信号量的使用 (必须放在子线程 dispatch_semaphore_wait会卡死主线程​​​​​​​)

                 信号量实现方式一:
 

- (void)serialBySemaphore {
    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

        [self requestOneWithSuccessBlock:^{
            dispatch_semaphore_signal(semaphore);
        }];

        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        [self requestTwoWithBlock:^{
        }];
    });
}

                           备注:执行到dispatch_semaphore_wait时，由于信号量为0，进行等待，请求1完成后调用dispatch_semaphore_signal ，信号量不再为0，接着执行请求2

                   信号量实现方式二(串行队列异步执行):
 

    dispatch_queue_t serialQueue = dispatch_queue_create("xxx", DISPATCH_QUEUE_SERIAL);
    
    // 请求一
    dispatch_async(serialQueue, ^{
        dispatch_semaphore_t sema = dispatch_semaphore_create(0);
        // 模拟请求1 ↓
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            sleep(3);
            NSLog(@"任务1完成");
            dispatch_semaphore_signal(sema);
        });
        // 模拟请求 上
        dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
    });
    
    // 请求二
    dispatch_async(serialQueue, ^{
        dispatch_semaphore_t sema = dispatch_semaphore_create(0);
        // 模拟请求2 ↓
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            sleep(3);
            NSLog(@"任务2完成");
            dispatch_semaphore_signal(sema);
        });
        // 模拟请求 上
        dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
    });

-(void)serialByGroupWait {
    
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_enter(group);
    [self requestOneWithSuccessBlock:^{
        dispatch_group_leave(group);
    }];
    
    dispatch_group_enter(group);
    [self requestTwoWithBlock:^{
        dispatch_group_leave(group);
    }];
  // 1  2同时执行
    
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);// 1 2 执行完 下面才会执行
    
    dispatch_group_enter(group);
    [self requestThreeWithBlock:^{
        dispatch_group_leave(group);
    }];
    
  // 1 2 3 都完成 才会执行
    dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"all request  done!");
    });
}

- (void) serialByCallBack {
    [self requestOneWithSuccessBlock:^{
        [self requestTwoWithBlock:^{
        }];
    }];
}

-(void)concurrentBySemaphore {
 dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        dispatch_semaphore_t sema = dispatch_semaphore_create(0);
        [self requestOneWithSuccessBlock:^{
            dispatch_semaphore_signal(sema);
        }];
        dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        dispatch_semaphore_t sema = dispatch_semaphore_create(0);
        [self requestTwoWithSuccessBlock:^{
            dispatch_semaphore_signal(sema);
        }];
        dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"全部搞完了");
    });
}

- (void)concurrentTest1 {
    dispatch_group_t group = dispatch_group_create();
    for (int i = 0 ; i < 5; i++) {
        dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            dispatch_semaphore_t sema = dispatch_semaphore_create(0);
             // 模拟请求 ↓
            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
                sleep(3);
                NSLog(@"任务%d完成",i);
                 dispatch_semaphore_signal(sema);
            });
             // 模拟请求 上
            dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
        });
    }
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"全部搞完了");
    });
}
/*
执行结果
 00:21:38.413337+0800 mmmm[4595:182516] 任务1完成
 00:21:38.413337+0800 mmmm[4595:182518] 任务3完成
 00:21:38.413358+0800 mmmm[4595:182517] 任务2完成
 00:21:38.413358+0800 mmmm[4595:182515] 任务0完成
 00:21:38.413447+0800 mmmm[4595:182519] 任务4完成
 00:21:38.413843+0800 mmmm[4595:182428] 全部搞完了
*/

- (void)concurrentTest2 {
    dispatch_group_t group = dispatch_group_create();
    for (int i = 0 ; i < 5; i++) {
        dispatch_group_enter(group);
          // 模拟请求 ↓
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            sleep(3);
            NSLog(@"任务%d完成",i);
            dispatch_group_leave(group);
        });
          // 模拟请求 ↑
    }
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"全部搞完了");
    });
}
/*
执行结果：
2019-04-12 00:26:38.607040+0800 mmmm[4641:184613] 任务0完成
2019-04-12 00:26:38.607043+0800 mmmm[4641:184612] 任务2完成
2019-04-12 00:26:38.607059+0800 mmmm[4641:184611] 任务3完成
2019-04-12 00:26:38.607067+0800 mmmm[4641:184610] 任务1完成
2019-04-12 00:26:38.607088+0800 mmmm[4641:184625] 任务4完成
2019-04-12 00:26:38.607353+0800 mmmm[4641:184559] 全部搞完了
*/

- (void)serialTest1 {
    dispatch_semaphore_t sema = dispatch_semaphore_create(0);
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (int i = 0 ; i < 5; i++) {
            NSLog(@"开始%d",i);
            // 模拟请求 ↓
            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
                sleep(3);
                NSLog(@"任务%d完成",i);
                dispatch_semaphore_signal(sema);
            });
            // 模拟请求 上
           dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
        }
        
       NSLog(@"全部搞完了");
    });
}
/*
执行结果:
2019-04-12 01:31:45.291818+0800 mmmm[5417:215007] 开始0
2019-04-12 01:31:48.297299+0800 mmmm[5417:215008] 任务0完成
2019-04-12 01:31:48.297746+0800 mmmm[5417:215007] 开始1
2019-04-12 01:31:51.298592+0800 mmmm[5417:215008] 任务1完成
2019-04-12 01:31:51.298841+0800 mmmm[5417:215007] 开始2
2019-04-12 01:31:54.300477+0800 mmmm[5417:215008] 任务2完成
2019-04-12 01:31:54.300908+0800 mmmm[5417:215007] 开始3
2019-04-12 01:31:57.305197+0800 mmmm[5417:215008] 任务3完成
2019-04-12 01:31:57.305623+0800 mmmm[5417:215007] 开始4
2019-04-12 01:32:00.311062+0800 mmmm[5417:215008] 任务4完成
2019-04-12 01:32:00.311407+0800 mmmm[5417:215007] 全部搞完了

*/

- (void)serialTest2 {
    dispatch_group_t group = dispatch_group_create();
    for (int i = 0 ; i < 5; i++) {
        dispatch_group_enter(group);
        // 模拟请求 ↓
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            sleep(6 - i);
            NSLog(@"任务%d完成",i);
            dispatch_group_leave(group);
        });
        // 模拟请求 ↑
        dispatch_group_wait(group, DISPATCH_TIME_FOREVER); // 顺序执行与同步执行的不同点
    }
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"全部搞完了");
    });
}
/*
执行结果:
2019-04-12 00:33:46.020376+0800 mmmm[4748:188409] 任务0完成
2019-04-12 00:33:51.021098+0800 mmmm[4748:188409] 任务1完成
2019-04-12 00:33:55.022758+0800 mmmm[4748:188409] 任务2完成
2019-04-12 00:33:58.023783+0800 mmmm[4748:188409] 任务3完成
2019-04-12 00:34:00.027929+0800 mmmm[4748:188409] 任务4完成
2019-04-12 00:34:00.028444+0800 mmmm[4748:188374] 全部搞完了

*/

	//通过malloc_size函数获得，该函数返回的是系统给实例对象分配的内存大小，在64bit环境下，所获得的数值是16个字节的倍数。
	Person *person = [[Person alloc] init];
	NSLog(@"%zu", malloc_size((__bridge const void *)person));
	//可以通过allocWithZone查看源码，会调用calloc(1, size)函数；size_t size = cls->instanceSize(extraBytes);
    size_t instanceSize(size_t extraBytes) {
        size_t size = alignedInstanceSize() + extraBytes;
        // CF requires all objects be at least 16 bytes.
        if (size < 16) size = 16;
        return size;
    }

	//64bit环境下，可以通过class_getInstanceSize函数获得; 
	NSLog(@"%zu", class_getInstanceSize([Person class]));
	//通过class_getInstanceSize检查源码，是通过alignedInstanceSize的内存对齐原理，返回实例对象的成员变量在内存中所占字节的大小;
	// Class's ivar size rounded up to a pointer-size boundary.
    uint32_t alignedInstanceSize() {
        return word_align(unalignedInstanceSize());
    }

	//64bit
	size_t i = sizeof(int);//4个字节
    size_t longInt = sizeof(NSInteger);//8个字节
    NSLog(@"%zu, %zu", i, longInt);

        // instance对象，实例对象
        NSObject *object1 = [[NSObject alloc] init];
        NSObject *object2 = [[NSObject alloc] init];
        
        // class对象，类对象
        // class方法返回的一直是class对象，类对象
        Class objectClass1 = [object1 class];
        Class objectClass2 = [object2 class];
        Class objectClass3 = object_getClass(object1);
        Class objectClass4 = object_getClass(object2);
        Class objectClass5 = [NSObject class];
        
        // meta-class对象，元类对象
        // 将类对象当做参数传入，获得元类对象
        Class objectMetaClass = object_getClass(objectClass5);

- (instancetype)init
{
self = [super init];
if (self) {
    self.isStoped = NO;
    __weak typeof(self) weakSelf = self;//防止循环引用
    self.thread = [[CCThread alloc] initWithBlock:^{
        //--------OC语言运行RunLoop----------
        //往RunLoop中添加source
        //因为Mode中没有任何Source0\Source1\Timer\Observer，RunLoop就会立马退出。
        [[NSRunLoop currentRunLoop] addPort:[[NSPort alloc] init] forMode:NSDefaultRunLoopMode];
        //运行RunLoop
        //[[NSRunLoop currentRunLoop] run];//会进入无休止的loop，无法停止，它专门用于开启一个永不销毁的线程(NSRunLoop)
        while (weakSelf && !weakSelf.isStoped) {//增加while循环，使RunLoop不会执行完就退出
            //[NSDate distantFuture]代表很长的时间，使RunLoop永不过期
            [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
        }
        
        
        //--------C语言运行RunLoop-----------
        //创建上下文（需要初始化一下结构体，因为auto局部变量，如果不初始化，会造成乱码的情况）
        CFRunLoopSourceContext context = {0};
        
        //创建source
        CFRunLoopSourceRef source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0, &context);
        
        //往RunLoop中添加source
        //因为Mode中没有任何Source0\Source1\Timer\Observer，RunLoop就会立马退出。
        CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopDefaultMode);
        
        //销毁source
        CFRelease(source);
        
        //启动RunLoop
        /**
         第二个参数：RunLoop过期时间
         第三个参数：returnAfterSourceHandled，设置为true，代表执行完source后就会退出当前loop；
                                       设置为false，代表执行完source后不会退出当前loop。
         */
        CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e10, false);
        
        NSLog(@"----end------");
    }];
    
    [self.thread start];
}
return self;
}

CFRunLoopStop(CFRunLoopGetCurrent());//停止/退出RunLoop。

            解决NSTimer在滑动时停止工作的问题:

                    kCFRunLoopDefaultMode（NSDefaultRunLoopMode）：App的默认Mode，通常主线程是在这个Mode下运行。
 UITrackingRunLoopMode：界面跟踪 Mode，用于 ScrollView 追踪触摸滑动，保证界面滑动时不受其他 Mode 影响。

                   开启一个NSTimer时，它是在RunLoop的kCFRunLoopDefaultMode模式；当UI界面ScrollView滑动的时候，RunLoop的currentModel就切换为UITrackingRunLoopMode模式；

                   RunLoop启动时只能选择一种模式运行，并且顶层的 RunLoop 的”commonModeItems”会被 RunLoop 自动更新到所有具有”Common”属性的 Mode 里去。又因为kCFRunLoopDefaultMode和UITrackingRunLoopMode这两种模式的commonModes都被标记为NSRunLoopCommonModes。

                  CommonModes：一个 Mode 可以将自己标记为”Common”属性（通过将其 ModeName 添加到 RunLoop 的 “commonModes” 中）。每当 RunLoop 的内容发生变化时，RunLoop 都会自动将 _commonModeItems 里的 Source/Observer/Timer 同步到具有 “Common” 标记的所有Mode里。

        所以有以下两种解决方案：

                将NSTimer都加入到这两种模式中。

                将NSTimer标记为NSRunLoopCommonModes。

        监控应用卡顿。

        性能优化。

#import "ViewController.h"

#define kNotificationName @"kNotificationName"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    // 初始化一个按钮
    UIButton *button = [[UIButton alloc] initWithFrame:CGRectMake(100, 100, 100, 50)];
    button.backgroundColor = [UIColor orangeColor];
    [button setTitle:@"触发通知" forState:UIControlStateNormal];
    [button addTarget:self action:@selector(buttonDown) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:button];

    // 注册通知
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(actionNotification:)
                                                 name:kNotificationName
                                               object:nil];

}

- (void) actionNotification: (NSNotification*)notification
{
//    NSString* message = notification.object;
//    NSLog(@"%@",message);
//    
//    sleep(3);
//    
//    NSLog(@"通知说话结束");

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        NSString* message = notification.object;
        NSLog(@"%@",message);

        sleep(3);

        NSLog(@"通知说话结束:%@",[NSThread currentThread]);

    });
}

- (void)buttonDown
{
    [[NSNotificationCenter defaultCenter] postNotificationName:kNotificationName object:@"通知说话开始"];
    //    NSLog(@"按钮说话");
    NSLog(@"按钮说话:%@",[NSThread currentThread]);

}

@end

- (void)buttonDown
{
    NSNotification *notification = [NSNotification notificationWithName:kNotificationName
                                                                 object:@"通知说话开始"];
    [[NSNotificationQueue defaultQueue] enqueueNotification:notification
                                               postingStyle:NSPostASAP];

//    [[NSNotificationCenter defaultCenter] postNotificationName:kNotificationName object:@"通知说话开始"];

    NSLog(@"按钮说话");

}