多线程

<span style="font-size:18px;">- (void)dead
{
    // NSThread提供的一些方法
    
    // 1.获取当前的线程
    
    NSThread *currentThread = [NSThread currentThread];
    NSLog(@"当前线程：%@", currentThread);
    
    // 2.获取主线程
    
    NSThread *mainThread = [NSThread mainThread];
    NSLog(@"主线程：%@", mainThread);
    
    // 3.判断当前的线程是不是主线程
    
    BOOL result = [NSThread isMainThread];
    NSLog(@"是不是主线程:%d", result);
    
    // 4.让当前的线程休眠几秒
//    [NSThread sleepForTimeInterval:2];
    
    
    
    
    int a = 0;
    
    NSLog(@"开始");
    for (int i = 0 ; i < 600000000;  i++) {
        a++;
    }
    
    NSLog(@"%d", a);
    
}</span>

NSObject

<span style="font-size:18px;">- (IBAction)NSObjectAction:(id)sender {
    
//    [self dead];
    
    // 1.第一种多线程的实现方式
    
    // NSObject自带的多线程实现
    
    
    // 优点：写法简单
    
    // 缺点：对于线程的安全没有做处理
    
    [self performSelectorInBackground:@selector(dead) withObject:nil];
    
    
    
}</span>

NSThread

- (IBAction)NSTheadAction:(id)sender {
    
    // 2.NSThread类 线程类，这个类的一个对象就代表一个线程
    
    // 创建一个对象就相当于创建一个线程
    
    
    // 优点：可以对线程本身进行设置操作
    // 缺点：使用太繁琐，线程的安全也需要开发者自己处理

    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(dead) object:nil];
    
    thread.name = @"随便";
    
    
    // 开始线程
    [thread start];
    
    [thread release];
    
    
}

NSOperation

- (IBAction)NSOperationAction:(id)sender {
    
    // 3.NSOperation类 代表一个任务
    
    // 这个类的对象本身没有任何多线程操作，执行的时候会自动放进一个当前的线程
    // 这个类不能直接使用，需要创建子类使用
    
    MyOperation *op = [[MyOperation alloc] init];
    
    // 开始执行，会在当前的线程直接执行
    [op start];
    
    [op release];
    
    // 系统提供了两个子类
    
//    NSInvocationOperation
//    NSBlockOperation
    
    
    
}

NSOperationQueue

- (IBAction)NSOperationQueueAction:(id)sender {
    
    // NSOperationQueue 操作队列， 作用：管理一系列的线程和任务
    
    // 机制：不断的将任务分配给线程，当线程执行完毕，会回到线程池中等待任务分配
    
    // 优点：节省系统的资源利用，能够很好的规划线程的使用，不需要关心线程的安全问题
    // 缺点：没有
    
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 主队列，一个串行队列，只管理一个线程：主线程
    [NSOperationQueue mainQueue];
    
    // 最大并发数
    [queue setMaxConcurrentOperationCount:2];
    
    // 给队列里添加任务
    
//    MyOperation *op1 = [[MyOperation alloc] init];
//    [queue addOperation:op1];
//    [op1 release];
    
    [queue addOperationWithBlock:^{
        [self dead];
    }];
    [queue addOperationWithBlock:^{
        [self dead];
    }];
    [queue addOperationWithBlock:^{
        [self dead];
    }];
    [queue addOperationWithBlock:^{
        [self dead];
    }];
    
}

GCD

- (IBAction)GCDAction:(id)sender {
    
    // GCD
    
    // 创建一个队列
    // 参数1：队列名
    // 参数2：队列的类型
    //DISPATCH_QUEUE_CONCURRENT  并行
    //DISPATCH_QUEUE_SERIAl      串行
    dispatch_queue_t myQueue = dispatch_queue_create("lizhi", DISPATCH_QUEUE_CONCURRENT);
    
    // 在队列中分配任务
    
    // 参数1：在哪个队列中分配任务
    // 参数2：在block中写要执行的内容
//    dispatch_async(myQueue, ^{
//        [self dead];
//    });
    
    
    // 系统提供了5个队列供开发者使用：全都是单例
    
    // 1个串行队列，叫主队列，负责对主线程进行调度处理
    // 4个并行队列，叫全局对列，负责调度所有的子线程
    
    
    // 1.获得主队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    
//    dispatch_async(mainQueue, ^{
//        [self dead];
//    });
    
    
    // 2.获得全局队列
    // 参数1：获取哪一个全局队列, 有4个不同的优先级
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    
    dispatch_async(globalQueue, ^{
        [self dead];
    });
    dispatch_async(globalQueue, ^{
        [self dead];
    });
    dispatch_async(globalQueue, ^{
        [self dead];
    });
    dispatch_async(globalQueue, ^{
        [self dead];
    });
    
    
    // 原则上，所有对数据的处理，都需要开辟子线程进行
    
    
    
    
    // GCD的常用写法
    // 在子线程申请数据
    dispatch_async(globalQueue, ^{
        
        NSString *str = @"http://pic4.nipic.com/20090922/1963767_165747613683_2.jpg";
        
        // 利用NSData的一个同步方法
        NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:str]];
        
        // 将数据转为一个图片
        UIImage *image = [UIImage imageWithData:data];
        
        dispatch_async(mainQueue, ^{
           
            // 在主线程中写对UI界面的处理，赋值，刷新。。。
            
            self.imageView.image = image;
            
            
        });
        
        
    });
    
    
    // 延时执行
 
    NSLog(@"开始延时");
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"延时执行");
    });
    
    
    // 单例执行
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"只执行一次");
    });
    
}