多线程

[code=language-objectivec]- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.

NSThread*thread=[[NSThread alloc]initWithTarget:self selector:@selector(threadOne:) object:nil];
[thread setName:@"线程1"];
[thread setThreadPriority:1.0];
[thread start];
NSThread*thread2=[[NSThread alloc]initWithTarget:self selector:@selector(threadTwo:) object:nil];
[thread2 start];
for (int i=0; i<10; i++) {
NSLog(@"主线程---%d",i);
}

/*******线程执行完的回调*******/
//监听线程结束的通知，并回调(系统发送通知)
//NSThreadWillExitNotification
[[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(threadExit:) name:NSThreadWillExitNotification object:nil];

}
//线程方法
-(void)threadOne:(id)sender
{
for (int i=0; i<10; i++) {
NSLog(@"线程1----------%d",i);
}
}
//线程方法
-(void)threadTwo:(id)sender
{
for (int i=0; i<10; i++) {
NSLog(@"线程2----------%d",i);
}
}
////线程结束调用
-(void)threadExit:(NSNotification*)notification
{
NSLog(@"%@",notification.object);
if ([[notification.object name] isEqualToString:@"线程1"]) {
NSLog(@"线程 1 结束了");
}
}

[code=language-objectivec]- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.

// 一 创建任务
//1 使用NSInvocationOperation 创建一个任务
NSInvocationOperation*invocation=[[NSInvocationOperation alloc]initWithTarget:self selector:@selector(invocation) object:nil];

//2 NSBlockOperation 创建任务
NSBlockOperation*blockOperation1=[NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 10; i ++) {
NSLog(@"blockOperation1-->%d", i);
}
}];
NSBlockOperation*blockOperation2=[NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 10; i ++) {
NSLog(@"blockOperation2-->%d", i);
}
}];

//添加一个依赖关系   invacation1依赖于blockOperation1的执行完毕
[invocation addDependency:blockOperation1];
[blockOperation1 addDependency:blockOperation2];

//        [blockOperation1 addExecutionBlock:^{
//            for (int i = 0; i < 10; i ++) {
//                NSLog(@"blockOperation2----->%d", i);
//            }
//        }];

//2、创建一个任务队列   并行关系  异步关系
//队列中的任务也是异步并行的关系
NSOperationQueue *queue1 = [[NSOperationQueue alloc] init];

//设置最大并发的任务数
queue1.maxConcurrentOperationCount = 3;

//把任务添加队列里   添加任务立即执行任务
[queue1 addOperation:invocation];
[queue1 addOperation:blockOperation1];
[queue1 addOperation:blockOperation2];
//直接添加block
//     [queue1 addOperationWithBlock:^{
//     for (int i = 0; i < 10; i ++) {
//     NSLog(@"block----->%d", i);
//     }
//     //异步线程
//     //执行耗时的网路下载任务
//
//     //从异步线程回到主线程
//     [[NSOperationQueue mainQueue] addOperationWithBlock:^{
//     //在这个地方-->UI进程
//     //拿到已下载的数据刷新UI
//
//     }];
//
//     }];

//    主进程的任务
for (int i = 0; i < 40; i ++) {
NSLog(@"mainQueue-->%d", i);
}

}
-(void)invocation{

for (int i =0; i<10; i++) {

NSLog(@"invocation-->%d", i);

}
}

[code=language-objectivec]//定义带参的宏
#define printLog(value)  for (int i = 0 ; i < 10; i ++) {NSLog([NSString stringWithFormat:@"%@-->%d", value, i]);}

- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.

//***********  GCD的串并行队列、同异步任务  *************//

/*
在 GCD 中，加入了两个非常重要的概念： 任务 和 队列。

任务：即操作，你想要干什么，说白了就是一段代码，在 GCD 中就是一个 Block，所以添加任务十分方便。任务有两种执行方式： 同步执行 和 异步执行，他们之间的区别是 是否会创建新的线程。
同步执行：只要是同步执行的任务，都会在当前线程执行，不会另开线程。
异步执行：只要是异步执行的任务，都会另开线程，在别的线程执行。

队列：用于存放任务。一共有两种队列， 串行队列 和 并行队列。

串行队列 中的任务会根据队列的定义 FIFO 的执行，一个接一个的先进先出的进行执行。
说明：放到串行队列的任务，GCD 会 FIFO（先进先出） 地取出来一个，执行一个，然后取下一个，这样一个一个的执行。

并行队列 中的任务根据同步或异步有不同的执行方式。虽然很绕，但请看下表：
说明：放到串行队列的任务，GCD 也会 FIFO的取出来，但不同的是，它取出来一个就会放到别的线程，然后再取出来一个又放到另一个的线程。这样由于取的动作很快，忽略不计，看起来，所有的任务都是一起执行的。不过需要注意，GCD 会根据系统资源控制并行的数量，所以如果任务很多，它并不会让所有任务同时执行。

总结： 同步异步--会不会开启新的线程，串行并行--队列里面的任务可不可以一起执行
同步在当前线程 ，一个一个执行。异步串行--开启了新的线程，在新的线程里串行（队列里的第一个任务执行万才能执行第二个任务）。开启了新的线程，在新的线程里并行。
*/
//定义一个GCD队列
//参数1   标识符
//参数2   队列类型 DISPATCH_QUEUE_CONCURRENT 并行  DISPATCH_QUEUE_SERIAL 串行
//    dispatch_queue_t queue_concurrent = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
//    dispatch_queue_t queue_serial = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);

//异步
//参数1   GCD队列
//参数2   待执行Block
//        dispatch_async(queue_concurrent, ^{
//            printLog(@"并行-异步1")
//
//        });
//    dispatch_async(queue_concurrent, ^{
//        printLog(@"并行-异步2")
//
//    });
//        dispatch_async(queue_serial, ^{
//            printLog(@"串行-异步1")
//        });
//    dispatch_async(queue_serial, ^{
//        printLog(@"串行-异步2")
//    });
//同步
//        dispatch_sync(queue_concurrent, ^{
//            printLog(@"并行-同步1")
//        });
//    dispatch_sync(queue_concurrent, ^{
//        printLog(@"并行-同步2")
//    });
//        dispatch_sync(queue_serial, ^{
//            printLog(@"串行-同步1")
//        });
//    dispatch_sync(queue_serial, ^{
//        printLog(@"串行-同步2")
//    });

//    printLog(@"主线程")

//***********  GCD的全局队列、主队列  *************//
//全局队列是一个并行队列
//参数1  全局队列优先级类型
//参数2  保留参数

dispatch_queue_t global_queue=dispatch_get_global_queue(0, 0);

dispatch_async(global_queue, ^{
printLog(@"全局队列异步")
});
//    dispatch_sync(global_queue, ^{
//        printLog(@"全局队列同步")
//    });
//
//    //主队列
//    dispatch_queue_t main_queue=dispatch_get_main_queue();
//    //一般在其他队列里回调主队列，刷新UI类操作
//        dispatch_async(main_queue, ^{
//            printLog(@"主队列异步")
//        });
//
//        dispatch_async(dispatch_get_global_queue(0, 0), ^{
//            //下载数据文件
//
//           dispatch_async(dispatch_get_main_queue(), ^{
//              //刷新UI
//
//           });
//
//        });

//***********  GCD组的使用  *************//
//创建GCD的组

//        dispatch_group_t group = dispatch_group_create();
//        //添加任务
//        dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
//           printLog(@"组异步任务1")
//        });
//        dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
//           printLog(@"组异步任务2")
//        });
//        //添加回调任务
//        dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{
//            printLog(@"第三个任务")
//        });

printLog(@"主线程");

}