//  MainViewController.m
//  多线程-01.大任务
//  Created by apple on 13-10-7.
#import "MainViewController.h"
@interface MainViewController ()
@property (weak, nonatomic) UIImageView *imageView;
@end
@implementation MainViewController
/*
 NSObject多线程方法
 
 1. [NSThread currentThread] 可以返回当前运行的线程
    num = 1 说明是主线程
    在任何多线程技术中(NSThread,NSOperation,GCD)，
	均可以使用此方法，查看当前的线程情况。
 
 2. 新建后台线程，调度任务
    [self performSelectorInBackground:@selector(bigTask)
										withObject:nil]
 
    使用performSelectorInBackground是可以修改UI的，
	但是,强烈不建议如此使用。
 
 3. 更新界面
    使用performSelectorOnMainThread可以在主线程上执行任务。
	绝大多数最后一个参数是YES,即等待,直到它执行完
    提示：NSObject对象均可以调用此方法。
 
 4. 内存管理
    线程任务要包在@autoreleasepool（自动释放池）中，
				否则容易引起内存泄露，而且非常难发现。
 */
- (void)viewDidLoad
{
    [super viewDidLoad];
	// 创建第1个按钮,并为其添加点击事件
    UIButton *btn1 = [UIButton buttonWithType:UIButtonTypeRoundedRect];
    [btn1 setFrame:CGRectMake(110, 100, 100, 40)];
    [btn1 setTitle:@"大任务" forState:UIControlStateNormal];
    [btn1 addTarget:self action:@selector(btnClick_1)
						  forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:btn1];
	// 创建第2个按钮,并为其添加点击事件
    UIButton *btn2 = [UIButton buttonWithType:UIButtonTypeRoundedRect];
    [btn2 setFrame:CGRectMake(110, 200, 100, 40)];
    [btn2 setTitle:@"小任务" forState:UIControlStateNormal];
    [btn2 addTarget:self action:@selector(btnClick_2) 
						  forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:btn2];
    NSLog(@"%@", [NSThread currentThread]);
	// 当前主线程中设置头像
    UIImageView *imageView = [[UIImageView alloc]initWithFrame:
										CGRectMake(110, 260, 100, 100)];
    UIImage *image = [UIImage imageNamed:@"头像1.png"];
    [imageView setImage:image];
    [self.view addSubview:imageView];
    self.imageView = imageView;
}
// 响应按钮1的点击事件
- (void)btnClick_1
{
    // 在后台调用耗时操作
    // performSelectorInBackground会新建一个后台线程，
	// 并在该线程中执行调用的方法
    [self performSelectorInBackground:@selector(btn_1_bigTask)
										withObject:nil];
    NSLog(@"大任务按钮： %@", [NSThread currentThread]);
}
#pragma mark 耗时操作
- (void)btn_1_bigTask
{
    @autoreleasepool {        
        for (NSInteger i = 0; i < 300; i++) {
            NSString *str = [NSString stringWithFormat:@"i = %i", i];
            NSLog(@"%@", str);
        }
        NSLog(@"大任务 - %@", [NSThread currentThread]);
        UIImage *image = [UIImage imageNamed:@"头像2.png"];
        // 在主线程中修改self.imageView的image
		// 调用self即当前控制器的方法,在主线程中设置头像
        [self performSelectorOnMainThread:@selector(changeImage:) 
							  withObject:image waitUntilDone:YES];
		// 直接调用self.imageView自己的setImage:方法,并传递参数image
        [self.imageView performSelectorOnMainThread:@selector(setImage:)
									withObject:image waitUntilDone:YES];
    }
}
// 自定义方法,设置头像
- (void)changeImage:(UIImage *)image
{
    NSLog(@"修改头像 %@", [NSThread currentThread]);
    [self.imageView setImage:image];
}

// 响应按钮2的点击,调用自定义方法
- (void)btnClick_2
{
    NSLog(@"小任务按钮：%@", [NSThread currentThread]);
    [self btn_2_smallTask];
}
// 自定义方法
- (void)btn_2_smallTask
{
    NSString *str = nil;
    for (NSInteger i = 0; i < 30000; i++) {
        str = [NSString stringWithFormat:@"i = %i", i];
    }
    NSLog(@"%@", str);
    NSLog(@"小任务 - %@", [NSThread currentThread]);
}
@end

//  MainViewController.m
//  多线程-02.加载图片
//  Created by apple on 13-10-7.
#import "MainViewController.h"
@interface MainViewController ()
// 图像集合
@property (strong, nonatomic) NSSet *imageViewSet;
// 定义操作队列,NSOperationQueue
@property (strong, nonatomic) NSOperationQueue *operationQueue;
@end
@implementation MainViewController
/*
 1. NSThread
    1> 类方法 detachNewThreadSelector
        直接启动线程，调用选择器方法
 
    2> 成员方法 initWithTarget
        需要使用start方法，才能启动实例化出来的线程
 
    优点：简单
    缺点：
        * 控制线程的生命周期比较困难
        * 控制并发线程数
		* 存在死锁隐患
        * 先后顺序困难
        例如：下载图片(后台线程) -> 滤镜美化(后台线程) -> 更新UI(主线程)
 
 2. NSOperation
    1> NSInvocationOperation
    2> NSBlockOperation
 
    定义完Operation之后，将操作添加到NSOperationQueue即可启动线程，执行任务
 
    使用：
    1>  setMaxConcurrentOperationCount 可以控制同时并发的线程数量
    2>  addDependency 可以指定线程之间的依赖关系，
					  从而达到控制线程执行顺序的目的,如先下载,再渲染图片
 
    提示：
    要更新UI，需要使用[NSOperationQueue mainQueue]addOperationWithBlock:
    在主操作队列中更新界面
 
 3. GCD
     1) 全局global队列,如果是同步,则不开线程,在主队列中执行
     方法：dispatch_get_global_queue（获取全局队列）
     优先级：DISPATCH_QUEUE_PRIORITY_DEFAULT
     所有任务是并发（异步）执行的
     
     2) 串行队列  必须开一条新线程,全是顺序执行的
     方法：dispatch_queue_create（创建串行队列，串行队列不能够获取）
     提示：队列名称可以随意，不过不要使用@
     
     3) 主队列
     主线程队列
     方法：dispatch_get_main_queue（获取主队列）
 
    在gcd中，同步还是异步取决于任务执行所在的队列，更方法名没有关系
 
    具体同步、异步与三个队列之间的关系，一定要反复测试，体会！
	
  4.全局队列（可能会开启多条线程,如果是同步方法,则不开线程,只在主线程里）
		dispatch_queue_t queue = dispatch_get_global_queue(
						DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
		串行队列（只可能会开启一条线程）
		dispatch_queue_t queue = dispatch_queue_create("myQueue", 
										DISPATCH_QUEUE_SERIAL);
		主队列
		dispatch_get_main_queue();

	异步操作
		dispatch_async 异步方法无法确定任务的执行顺序
		

	同步操作
		dispatch_sync 同步方法会依次执行，能够决定任务的执行顺序
		同步操作与队列无关,所有的队列的同步,都是顺序执行的
		更新界面UI时，最好使用同步方法

	GCD的优点：
		充分利用多核
		所有的多线程代码集中在一起，便于维护
		GCD中无需使用@autoreleasepool

		如果要顺序执行，可以使用dispatch_sync同步方法
		dispatch_async无法确定任务的执行顺序
		调用主线程队列任务更新UI时，最好使用同步方法
	单例：
		保证在内存中永远只有类的单个实例

		建立方法：
		1,声明一个静态成员变量，记录唯一实例
		2,重写allocWithZone方法
			allocWithZone方法是对象分配内存空间时，最终会调用的方法，
			重写该方法，保证只会分配一个内存空间
		3,建立sharedXXX类方法，便于其他类访问
 */
- (void)viewDidLoad
{
    [super viewDidLoad];
	// 自定义方法,设置UI界面
    [self setupUI];
    // 实例化操作队列,NSOperationQueue
    self.operationQueue = [[NSOperationQueue alloc]init];
}
// 自定义方法,设置UI界面
- (void)setupUI
{
    // 实例化图像视图集合
    NSMutableSet *imageSet = [NSMutableSet setWithCapacity:28];
    // 虽然只有17张图片，但是每行显示4张，一共显示7行(重复使用)
	// 每张小图片宽 80,高 50
    NSInteger w = 80;
    NSInteger h = 50;
	// 弄出7行 X　4列图片
    for (NSInteger row = 0; row < 7; row++) {
        for (NSInteger col = 0; col < 4; col++) {
            // 计算图片的位置
			// 第几列 即所在的列数 决定了x坐标
			// 第几行 即所在的行数 决定了y坐标
            NSInteger x = col * w;
            NSInteger y = row * h;
            UIImageView *imageView = [[UIImageView alloc]initWithFrame:CGRectMake(x, y, w, h)];
            /* 下面是不使用多线程,设置图片
            NSInteger index = (row * 4 + col) % 17 + 1;
            NSString *imageName = [NSString stringWithFormat:@"NatGeo%02d.png", index];
            UIImage *image = [UIImage imageNamed:imageName];
            [imageView setImage:image];
			*/
			// 因为要使用多线程设置图片,所以这只添加imageView,并不设置图片
            [self.view addSubview:imageView];
            [imageSet addObject:imageView];
        }
    }
	// 成员变量 NSSet,记住所有的imageSet,方便多线程方法中为其设置图片
    self.imageViewSet = imageSet;
    // 添加按钮
    UIButton *btn = [UIButton buttonWithType:UIButtonTypeRoundedRect];
    [btn setFrame:CGRectMake(110, 385, 100, 40)];
    [btn setTitle:@"设置图片" forState:UIControlStateNormal];
    [btn addTarget:self action:@selector(click) 
							forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:btn];
}
#pragma mark 按钮的监听方法,设置图片
- (void)click
{
	// 调用GCD 设置图片
    [self gcdLoad];
}
// 多线程之NSThread,类方法detach线程,或者alloc创建线程,并手动start线程
- (void)threadLoad
{
	// 遍历成员变量NSSet 为每一个imageView设置图片
    for (UIImageView *imageView in self.imageViewSet) {        
        // 方式1,类方法，detach分离,新建28条线程,并自动调用threadLoadImage方法
        [NSThread detachNewThreadSelector:@selector(threadLoadImage:)
									toTarget:self withObject:imageView];
        // 方式2,alloc创建线程,并需要手动开启线程,才会执行threadLoadImage方法
        NSThread *thread = [[NSThread alloc]initWithTarget:self
					selector:@selector(threadLoadImage:) object:imageView];
		// alloc出来的线程,必须手动start才有效			
        [thread start];
    }
}
// NSThread线程的任务:加载图片方法
- (void)threadLoadImage:(UIImageView *)imageView
{
	// 设置imageView的图片
    // 线程方法一定要加autoreleasepool
    @autoreleasepool {
        // 28条线程,都在一开始睡眠1秒 
        [NSThread sleepForTimeInterval:1.0f];        
        NSInteger index = arc4random_uniform(17) + 1;
        NSString *imageName = [NSString stringWithFormat:@"NatGeo%02d.png",
															index];
        UIImage *image = [UIImage imageNamed:imageName];
        // imageView直接在主线程上执行setImage方法,更新UI,参数就是image
        [imageView performSelectorOnMainThread:@selector(setImage:)
										withObject:image waitUntilDone:YES];
    }
}
#pragma mark NSOperation方法
// 多线程之2,NSXxxOperation依赖关系演示
- (void)operationDemo
{
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"下载 %@", [NSThread currentThread]);
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"美化 %@", [NSThread currentThread]);
    }];
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"更新 %@", [NSThread currentThread]);
    }];
    // Dependency依赖,1完成,再执行2,最后执行3
    // 提示：依赖关系可以多重依赖
    // 注意：不要建立循环依赖,嵌套依赖
    [op2 addDependency:op1];
    [op3 addDependency:op2];
	// 将NSOperation添加到成员变量NSOperationQueue,操作队列中 
    [self.operationQueue addOperation:op3];
    [self.operationQueue addOperation:op1];
    [self.operationQueue addOperation:op2];
}
// 多线程之2,NSBlockOperation
- (void)operationBlockLoad
{
	// 遍历成员变量NSSet,为每一个imageView设置图片
    for (UIImageView *imageView in self.imageViewSet) {
		// 创建一个操作 NSOperation
        NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
			// 执行 当前控制器的 自定义方法,,operationLoadImage
            [self operationLoadImage:imageView];
        }];
        // 必须将操作添加到操作队列之中,才有效,注:会自动启动~
        [self.operationQueue addOperation:op];
    }
}
// 多线程之2,NSInvocationOperation
-(void)operationLoad
{
    // NSOperationQueue优点:可以设置同时并发执行的线程的数量
	// 即使开了20条线程,同一时刻也只会执行其中的4条线程
    [self.operationQueue setMaxConcurrentOperationCount:4];
	// 遍历成员变量NSSet,为每一个imageView设置图片
    for (UIImageView *imageView in self.imageViewSet) {
		// 创建一个操作 NSOperation
        NSInvocationOperation *op = [[NSInvocationOperation alloc]
				initWithTarget:self selector:@selector(operationLoadImage:) 
				object:imageView];
        // 如果直接调用operation的start方法，是在主线程队列上运行的，不会开启新的线程
        [op start];
        // 必须将操作Operation添加到操作队列，才会开启新的线程执行任务,注:自动开启
        [self.operationQueue addOperation:op];
    }
}
// 多线程之2,NSXxxOperation任务的具体代码,加载图片方法
- (void)operationLoadImage:(UIImageView *)imageView
{
    // 线程方法一定要加autoreleasepool
    @autoreleasepool {
        // 设置imageView的内容
		// 模拟网络延时
        [NSThread sleepForTimeInterval:1.0f];
        NSInteger index = arc4random_uniform(17) + 1;
        NSString *imageName = [NSString stringWithFormat:@"NatGeo%02d.png",
															index];
        UIImage *image = [UIImage imageNamed:imageName];
        // 必须在主线程队列上更新UI,必须使用NSOperationQueue mainQueue
        [[NSOperationQueue mainQueue]addOperationWithBlock:^{
            [imageView setImage:image];
        }];
    }
}
// 多线程之3,GCD,抽象程度最高,用户主要精力只要放在业务上即可
- (void)gcdDemo
{
    /*
     1. 全局global队列
     方法：dispatch_get_global_queue（获取全局队列）
     优先级：DISPATCH_QUEUE_PRIORITY_DEFAULT
     所有任务是并发（异步）执行的,会创建N条线程
     
     2. 串行队列
     方法：dispatch_queue_create（创建串行队列，串行队列不能够获取）
     提示：队列名称可以随意，不过不要使用@
	 任务是同步,只会创建一个线程
     
     3. 主队列
     主线程队列
     方法：dispatch_get_main_queue（获取主队列）
     
     在gcd中，同步还是异步取决于任务执行所在的队列，更方法名没有关系
		如果是全局队列就是异步,会创建多条线程
		如果是自创建的队列,则是串行,同步的,且只会创建一条线程
	 
	 派发dispatch_
     异步async不执行，并发执行
     优先级priority，使用默认优先级即可
     1. 在全局队列中调用异步任务
     1) 全局队列，全局调度队列是有系统负责的，开发时不用考虑并发线程数量问题
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
     串行队列，需要创建，不能够get
     DISPATCH_QUEUE_SERIAL串行队列
     
    dispatch_queue_t queue = dispatch_queue_create("myQueue",
									  DISPATCH_QUEUE_SERIAL);
	GCD是基于C语言的框架
	工作原理：
	让程序平行排队的特定任务，根据可用的处理资源，安排它们在任何可用的处理器上执行任务
	要执行的任务可以是一个函数或者一个block
	底层是通过线程实现的，不过程序员可以不必关注实现的细节
	GCD中的FIFO队列称为dispatch queue，可以保证先进来的任务先得到执行
	dispatch_notify 可以实现监听一组任务是否完成，完成后得到通知
	GCD队列：
	全局队列：所有添加到全局队列中的任务都是并发执行的
	串行队列：所有添加到串行队列中的任务都是顺序执行的
	主队列：所有添加到主队列中的任务都是在主线程中执行的
*/
    // 主队列,即在主线程上运行
    dispatch_queue_t queue = dispatch_get_main_queue();
    // 2) 在主队列中没有异步和同步,所有都是在主线程中完成的 
    dispatch_async(queue, ^{
        NSLog(@"任务1 %@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务2 %@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务3 %@", [NSThread currentThread]);
    });
}
// 多线程之3, GCD加载图像,具体的核心业务,为NSSet中每个imageView设置图片
- (void)gcdLoad
{
    // 1) 获取全局队列,可以执行异步
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
	// 遍历成员变量NSSet,为每一个imageView设置图片
    for (UIImageView *imageView in self.imageViewSet) {
        // 2) 在全局队列上执行异步方法，开启N条线程,加载并设置图像
        dispatch_async(queue, ^{
            NSLog(@"GCD- %@", [NSThread currentThread]);
            NSInteger index = arc4random_uniform(17) + 1;
            NSString *imageName = [NSString stringWithFormat:@"NatGeo%02d.png",
																index];
            // 通常此异步方法里面获取的image是网络上的
            UIImage *image = [UIImage imageNamed:imageName];
            // 3) 最后必须在主线程队列中设置图片，异步
            dispatch_async(dispatch_get_main_queue(), ^{
                NSLog(@"更新图片- %@", [NSThread currentThread]);
                [imageView setImage:image];
            });
        });
    }
}
@end

//  MainViewController.m
//  多线程-03.卖票
//  Created by apple on 13-10-7.
/*
系统预设
	共有30张票可以销售（开发时可以少一些，专注实现）
	售票工作由两个线程并发进行
	没有可出售票据时，线程工作停止
	两个线程的执行时间不同，模拟售票人员效率不同
	使用一个多行文本框公告售票进度（主线程更新UI）
线程工作安排
	主线程：负责更新UI
	线程1：模拟第1名卖票员
	线程2：模拟第2名卖票员
	两个线程几乎同时开始卖票
*/
#import "MainViewController.h"
#import "Ticket.h"
@interface MainViewController ()
@property (weak, nonatomic) UITextView *textView;
@property (strong, nonatomic) NSOperationQueue *operationQueue;
@end
@implementation MainViewController
- (void)viewDidLoad
{
    [super viewDidLoad];
    // 建立多行文本框
    UITextView *textView = [[UITextView alloc]initWithFrame:self.view.bounds];
    // 禁止编辑
    [textView setEditable:NO];
    [self.view addSubview:textView];
    self.textView = textView;
    // 预设可以卖30张票
    [Ticket sharedTicket].tickets = 30;
    // 实例化操作队列,NSOperationQueue
    self.operationQueue = [[NSOperationQueue alloc]init];
    // 调用自定义方法,开始卖票
    [self operationSales];
}
// 多线程卖票之一:NSOperation
- (void)operationSales
{
    // 提示，operation中没有群组任务完成通知功能
    // 设置操作队列,最大同时并发线程数:两个线程卖票
    [self.operationQueue setMaxConcurrentOperationCount:2];
    [self.operationQueue addOperationWithBlock:^{
        [self operationSaleTicketWithName:@"op-1"];
    }];
    [self.operationQueue addOperationWithBlock:^{
        [self operationSaleTicketWithName:@"op-2"];
    }];
    [self.operationQueue addOperationWithBlock:^{
        [self operationSaleTicketWithName:@"op-3"];
    }];
}
// 多线程卖票之一:NSOperation 核心卖票代码
- (void)operationSaleTicketWithName:(NSString *)name
{
    while (YES) {
        // 同步锁synchronized要锁的范围，对被抢夺资源修改/读取的代码部分
        @synchronized(self) {
            // 判断是否还有票
            if ([Ticket sharedTicket].tickets > 0) {
                [Ticket sharedTicket].tickets--;
                // 提示，涉及到被抢夺资源的内容定义方面的操作，千万不要跨线程去处理
                NSString *str = [NSString stringWithFormat:
									@"剩余票数 %d 线程名称 %@", 
									[Ticket sharedTicket].tickets, name];
                
                // 在mainQueue主线程中更新UI
                [[NSOperationQueue mainQueue]addOperationWithBlock:^{
					// 调用自定义方法,更新编辑框的内容,并滚动至最后一行
                    [self appendContent:str];
                }];
            } else {
                NSLog(@"卖票完成 %@ %@", name, [NSThread currentThread]);
                break;
            }
        }
        // 模拟卖票休息,不同的窗口,工作效率不同
        if ([name isEqualToString:@"op-1"]) {
            [NSThread sleepForTimeInterval:0.6f];
        } else {
            [NSThread sleepForTimeInterval:0.4f];
        }
    }
}
#pragma mark 更新UI,追加当前余票数,到多行文本框
- (void)appendContent:(NSString *)text
{
    // 1. 取出多行文本框里面原来的内容
    NSMutableString *str = [NSMutableString 
							stringWithString:self.textView.text];
    // 2. 将text追加至textView内容的末尾
    [str appendFormat:@"%@\n", text];
    // 3. 使用追加后的文本，替换textView中的内容
    [self.textView setText:str];
    // 4. 将textView滚动至视图底部，保证能够及时看到新追加的内容
	// 参数1是index,参数2是截取的长度
    NSRange range = NSMakeRange(str.length - 1, 1);
	// 5.滚动到编辑框的最后一行
    [self.textView scrollRangeToVisible:range];
}
// 多线程卖票之二:NSThread
- (void)threadSales
{
	// 类方法创建新线程,并且直接运行
    [NSThread detachNewThreadSelector:@selector(threadSaleTicketWithName:)
									toTarget:self withObject:@"thread-1"];
	// 类方法创建新线程,并且直接运行								
    [NSThread detachNewThreadSelector:@selector(threadSaleTicketWithName:)
									toTarget:self withObject:@"thread-2"];
}
// 多线程卖票之二:NSThread 核心卖票代码
- (void)threadSaleTicketWithName:(NSString *)name
{
    // 使用NSThread时，线程调用的方法千万要使用@autoreleasepool
    @autoreleasepool {        
        while (YES) {
			// 同步锁synchronized要锁的范围，对被抢夺资源修改/读取的代码部分
            @synchronized(self) {
                if ([Ticket sharedTicket].tickets > 0) {
                    [Ticket sharedTicket].tickets--;
                    NSString *str = [NSString stringWithFormat:
									@"剩余票数 %d 线程名称 %@", 
									[Ticket sharedTicket].tickets, name];
                    // 在MainThread主线程中更新UI
					// 调用自定义方法,更新编辑框的内容,并滚动至最后一行
                    [self performSelectorOnMainThread:
								@selector(appendContent:) withObject:str
								waitUntilDone:YES];
                } else {
                    break;
                }
            }
            // 模拟卖票休息,不同的窗口,工作效率不同
            if ([name isEqualToString:@"thread-1"]) {
                [NSThread sleepForTimeInterval:1.0f];
            } else {
                [NSThread sleepForTimeInterval:0.1f];
            }
        }
    }
}
// 多线程卖票之三:GCD,单纯只创建三个异步任务分别卖票
- (void)gcdSales_without_group
{
    // 1) 创建全局队列
    dispatch_queue_t queue = dispatch_get_global_queue(
					DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 2) 创建三个异步任务分别卖票
    dispatch_async(queue, ^{
        [self gcdSaleTicketWithName:@"gcd-1"];
    });
    dispatch_async(queue, ^{
        [self gcdSaleTicketWithName:@"gcd-2"];
    });
    dispatch_async(queue, ^{
        [self gcdSaleTicketWithName:@"gcd-3"];
    });    
}
// 多线程卖票之三:GCD,创建组,将三个异步任务添加到组
- (void)gcdSales_with_group
{
    // 1) 创建全局队列
    dispatch_queue_t queue = dispatch_get_global_queue(
					DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);    
    // 2. GCD中可以将一组相关联的操作，定义到一个群组中
    // 定义到群组中之后，当所有线程完成时，可以获得通知
    // 3. 定义群组
    dispatch_group_t group = dispatch_group_create();
    // 4. 定义群组的异步任务
    dispatch_group_async(group, queue, ^{
        [self gcdSaleTicketWithName:@"gcd-1"];
    });
    dispatch_group_async(group, queue, ^{
        [self gcdSaleTicketWithName:@"gcd-2"];
    });
    // 3) 群组任务完成通知,当前组中的三个线程全部完成的时候,会调用~
    dispatch_group_notify(group, queue, ^{
        NSLog(@"卖完了");
    });
}
// 多线程卖票之三:GCD 核心卖票代码
- (void)gcdSaleTicketWithName:(NSString *)name
{
    while (YES) {
        // 同步锁synchronized要锁的范围，对被抢夺资源修改/读取的代码部分
        @synchronized(self) {
            if ([Ticket sharedTicket].tickets > 0) {
                [Ticket sharedTicket].tickets--;
                // 提示内容
                NSString *str = [NSString stringWithFormat:@"剩余票数 %d,
						线程名称 %@", [Ticket sharedTicket].tickets, name];
                // 在dispatch_get_main_queue主线程中更新UI
                dispatch_sync(dispatch_get_main_queue(), ^{
					// 调用自定义方法,更新编辑框的内容,并滚动至最后一行
                    [self appendContent:str];
                });
            } else {
                break;
            }
        }
        // 模拟卖票休息,不同的窗口,工作效率不同
        if ([name isEqualToString:@"gcd-1"]) {
            [NSThread sleepForTimeInterval:1.0f];
        } else {
            [NSThread sleepForTimeInterval:0.2f];
        }
    }
}
@end

//  Ticket.h
//  多线程-03.卖票
//  Created by apple on 13-10-7.
//  Copyright (c) 2013年 itcast. All rights reserved.

#import <Foundation/Foundation.h>

@interface Ticket : NSObject

// 实例化票据的单例
+ (Ticket *)sharedTicket;

// 在多线程应用中，所有被抢夺资源的属性需要设置为原子属性
// 系统会在多线程抢夺时，保证该属性有且仅有一个线程能够访问
// 注意：使用atomic属性，会降低系统性能，在开发多线程应用时，尽量不要资源
// 另外，atomic属性，必须与@synchronized（同步锁）一起使用

// 票数 atomic
@property (assign, atomic) NSInteger tickets;

@end

//  Ticket.m
//  多线程-03.卖票
//  Created by apple on 13-10-7.
//  Copyright (c) 2013年 itcast. All rights reserved.
#import "Ticket.h"
static Ticket *SharedInstance;
@implementation Ticket
/**
 实现单例模型需要做三件事情
 1. 使用全局静态变量记录住第一个被实例化的对象
    static Ticket *SharedInstance
 2. 重写allocWithZone方法，并使用dispatch_once_t，从而保证在多线程情况下，
    同样只能实例化一个对象副本
 3. 建立一个以shared开头的类方法实例化单例对象，便于其他类调用，同时不容易引起歧义
    同样用dispatch_once_t确保只有一个副本被建立
	
 关于被抢夺资源使用的注意事项
 
 在多线程应用中，所有被抢夺资源的属性需要设置为原子属性
 系统会在多线程抢夺时，保证该属性有且仅有一个线程能够访问
 
 注意：使用atomic属性，会降低系统性能，在开发多线程应用时，尽量不要抢资源
 另外，atomic属性，必须与@synchronized（同步锁）一起使用
 */
// 使用内存地址实例化对象，所有实例化方法，最终都会调用此方法
// 要实例化出来唯一的对象，需要一个变量记录住第一个实例化出来的对象
+ (id)allocWithZone:(NSZone *)zone
{
    // 解决多线程中，同样只能实例化出一个对象副本
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        SharedInstance = [super allocWithZone:zone];
    });
    return SharedInstance;
}
// 建立一个单例对象，便于其他类调用
+ (Ticket *)sharedTicket
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        SharedInstance = [[Ticket alloc]init];
    });
    return SharedInstance;
}
@end