多线程

1.NSThread : 建立线程非常简便，但需手动管理线程。

    //先创建 后启动

    NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(run) object:nil];

    [thread start];

    

    //创建并启动

    [NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];

    

    //其他用法

    [NSOperationQueue mainQueue]; //获取主线程

    [NSThread currentThread];     //获取当前线程

       num = 1;主线程

        num =其他子线程

2.NSOperation/NSOperationQueue

1>使用GCD的oc API

2>面向对象线程技术

3>提供了在GCD中不易实现的特性 最大并发数量，操作之间的依赖关系

2> NSOperationQueue(重点)
* 最大并发数设置：最大并发数最多同时执行多少个线程（2-3条为宜） 
- (void)setMaxConcurrentOperationCount:(NSInteger)cnt;

* 设置依赖

//设置依赖：可以改变顺序但不能相互依赖(需在添加操作到队列中之前设置)

（）下面这个执行顺序为 3 1 2

[operate1 addDEpendency:operate3]; //operate3 先执行 operate1依赖于operate3

[operate2 addDEpendency:operate1]; //operate1 先执行

3.GCD

基于C语言底层API

优势

1.将耗时的任务分配到其他线程执行，程序更加流畅。

2.使用简单，充分发挥多核处理的优势，

缺点：新建线程会消耗内存空间和cpu时间，线程太多会降低系统运行性能。

1>队列的类型

并发队列具体顺序不确定
串行队列按顺序执行

2>执行任务的方法类型

同步任务   是指在当前线程执行（同一个线程执行）
异步任务（有多条线程）具备开线程的能力

串行队列 同步任务 不需要新建线程
串行队列 异步任务   需要一个子线程 创建于回收不需要程序员管理
并行队列 同步任务   不需要创建子线程
并行队列 异步任务   有多少个任务 就开 N 个线程执行。

3>线程间通信
dispatch_async(
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
   //执行耗时的异步操作...
   dispatch_async(dispatch_get_main_queue(), ^{
       //回到主线程，执行UI刷新操作
   });
});

4>其他用法
dispatch_once
dispatch_after
dispatch_group_async\dispatch_group_notify

非ARC不要忘记release

以下是GCD的例子

- (void)viewDidLoad {
    [superviewDidLoad];
   
//    [self create_serial];
//    [self create_concurrent];
    [selfcreate_global];
//    [self create_main];
//    [self gcdSyncDemo];
}


#pragma mark -主线程队列

//为什么需要在主线程上工作呢？保证UI在主线程工作
//在iOS开发中，所有UI的更新工作，都必须在主线程上执行！
- (void)create_main
{
    dispatch_queue_t queue_t =dispatch_get_main_queue();
    //异步任务
    dispatch_async(queue_t, ^{
        for (int i=0; i<10; i++) {
            NSLog(@"%@-%d",[NSThreadcurrentThread],i);
        }
    });
   
//    //同步任务(阻塞主线程)
//    dispatch_sync(queue_t, ^{
//        NSLog(@"同步UI更新操作");
//    });
   
}

#pragma mark -全局队列
- (void)create_global
{
    //全局队队列和并行队列的区别
    //两者执行效果相同，全局队列不需要创建,没有名称，无法确定队列
    //多线程的优先级反转，低优先级的线程阻塞高优先级的线程，永远用DISPATCH_QUEUE_PRIORITY_DEFAULT
    dispatch_queue_t queue_t =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
   
    //同步任务
    for (int i=0; i<10; i++) {
       
        //顺序执行
        dispatch_sync(queue_t, ^{
            NSLog(@"同步任务%@-%d",[NSThreadcurrentThread],i);
        });
    }
   
    //异步任务
    for (int i=0; i<10; i++) {
        //并发执行
        dispatch_async(queue_t, ^{
            NSLog(@"异步任务%@-%d",[NSThreadcurrentThread],i);
        });
    }
}

#pragma mark -并行队列（具体执行顺序不确定）
- (void)create_concurrent
{
    dispatch_queue_t queue_t =dispatch_queue_create("cn.create_concurrent",DISPATCH_QUEUE_CONCURRENT);
   
    //异步任务
    for (int i=0; i<10; i++) {
        dispatch_async(queue_t, ^{
            NSLog(@"异步任务%@=%d",[NSThreadcurrentThread],i);
        });
    }
   
//    //同步任务
//    for (int i=0; i<10 ; i++) {
//        dispatch_sync(queue_t, ^{
//            NSLog(@"同步任务%@-%d",[NSThread currentThread],i);
//           
//             //并行队列，耗时的任务，同步里面包含同步，不会造成阻塞
//            dispatch_sync(queue_t, ^{
//                NSLog(@"同步任务%@-%d",[NSThread currentThread],i);
//            });
//           
//        });
//    }
}

#pragma mark -串行队列（按顺序执行）
- (void)create_serial
{
    //新建线程是有开销的，不能无休止的新建线程
    //number = 1主线程
    //number =其他数字子线程
   
    //应用案例
    //1>拍照
    //2>美化拍摄的照片
   
    //1.创建一个串行队列
    dispatch_queue_t queue_t =dispatch_queue_create("com.serial",DISPATCH_QUEUE_SERIAL);
   

    //异步任务
    for (int i=0; i<10; i++) {
        //异步任务具备开线程的能力
        dispatch_async(queue_t, ^{
            NSLog(@"异步任务%@-%d",[NSThreadcurrentThread],i);
        });
    }
   
    //同步任务
    for (int i=0; i<10; i++) {
        dispatch_sync(queue_t, ^{
            //同步任务不具备开线程的能力，只能在当前线程执行，即主线程
            NSLog(@"同步任务%@-%d",[NSThreadcurrentThread],i);
           
            //串行队列，耗时的任务，同步里面包含同步，会造成阻塞

            dispatch_sync(queue_t, ^{
                NSLog(@"同步任务%@-%d",[NSThreadcurrentThread],i);
            });
        });
    }
   
}