GCD

GCD与线程控制

最新推荐文章于 2017-09-20 17:22:14 发布

原创最新推荐文章于 2017-09-20 17:22:14 发布 · 371 阅读

0 ·

CC 4.0 BY-SA版权

iOS－问题汇总专栏收录该内容

88 篇文章

订阅专栏

#import "ViewController.h"

void function(void *name);

void function(void *name){

NSLog(@"%s",name);

}

@interface ViewController ()

//NSLock 负责对基本数据类型和对象类型加锁<全部有效>

@property(nonatomic,strong)NSLock *lock;

@end

@implementation ViewController

//服务器余票数

static NSInteger count=4000;

//买票方法

-(void)buyTicket{

[_lock lock];

count--;

NSLog(@"%ld",count);

[_lock unlock];

}

- (void)viewDidLoad {

[super viewDidLoad];

_lock=[[NSLock alloc]init];

//定义一个并行队列模拟买票系统

dispatch_queue_t contronQueue=dispatch_queue_create("contonQueue", DISPATCH_QUEUE_CONCURRENT);

__weak typeof (self)tempSelf=self;

dispatch_async(contronQueue, ^{

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

[tempSelf buyTicket];

}

});

dispatch_async(contronQueue, ^{

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

[tempSelf buyTicket];

}

});

//block 分为三种：堆区block，栈区block，全局block

//1.主队列 :串行队列 ,并且主队列执行的是主线程任务,其他队列都是子线程任务

//2.全局队列 :并行队列

//3.自定义队列{串行队列，并行队列}

//主队列和全局队列都是单例，主队列串行，全局队列并行.

//1.主队列

/*//获取主队列永远不要向主队列中添加延时器

dispatch_queue_t mainQueue=dispatch_get_main_queue();

//向主队列添加任务

dispatch_async(mainQueue, ^{

NSLog(@"第一个任务");

});

dispatch_async(mainQueue, ^{

NSLog(@"第二个任务");

});

dispatch_async(mainQueue, ^{

NSLog(@"第三个任务");

});

//设置延时执行

dispatch_time_t time=dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10*NSEC_PER_SEC));

dispatch_after(time, mainQueue, ^{

NSLog(@"这个十年后的你...");

});

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

NSLog(@"这个是你二十年后的你...");

});

//dispatch_apply

// dispatch_apply(3, mainQueue, ^(size_t t) {

// NSLog(@"我擦");

// NSLog(@"%zu",t);

// });*/

//2.全局队列

/*//获取全局队列

dispatch_queue_t globalQueue=dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

//相队列中添加任务

dispatch_async(globalQueue, ^{

NSLog(@"111111111111111");

});

dispatch_async(globalQueue, ^{

NSLog(@"2222222222222222");

});

dispatch_async(globalQueue, ^{

NSLog(@"3333333333333333");

});

dispatch_barrier_async(globalQueue, ^{

long sum=0;

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

sum+=i;

}

NSLog(@"执行完成,结果为:sum=%ld",sum);

});

//重复执行某一个任务

dispatch_apply(3, globalQueue, ^(size_t t) {

NSLog(@"我擦 %zu",t);

});

//分组任务

dispatch_group_t group=dispatch_group_create();

dispatch_group_async(group, globalQueue, ^{

NSLog(@"第一分组第一小队");

});

dispatch_group_async(group, globalQueue, ^{

NSLog(@"第一分组第二小队");

});

dispatch_group_async(group, globalQueue, ^{

NSLog(@"第一分组第三小队");

});

//和添加在队列的位置有关系，当处于队列末尾的时候，最后执行.

dispatch_group_notify(group, globalQueue, ^{

NSLog(@"jjjjjjjjjjjjjjjjjjjj");

});*/

//用此函数添加到队列的任务，需要等其他执行完后才可以执行其他的任务

//前提：自定义并发队列

//dispatch_barrier_async(<#dispatch_queue_t queue#>, <#^(void)block#>)

//3.自定义队列

//自定义串行队列

//第一个参数：队列标示符，可以获取到某一队列的标示符

//第二个参数：队列的类型(串行或者并行)

dispatch_queue_t serialQueue=dispatch_queue_create("serial", DISPATCH_QUEUE_SERIAL);

//添加task

dispatch_async(serialQueue, ^{

NSLog(@"第一个任务");

});

dispatch_async(serialQueue, ^{

NSLog(@"第二个任务");

});

dispatch_async(serialQueue, ^{

NSLog(@"第三个任务");

});

//获取队列的标示符

const char *s=dispatch_queue_get_label(serialQueue);

NSLog(@"%s",s);*/

//自定义并行队列

/*dispatch_queue_t consurrentQueue=dispatch_queue_create("concurrent", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(consurrentQueue, ^{

NSLog(@"1");

});

//必须等待barrier函数执行完余下的任务才会执行

//用来阻塞队列的

dispatch_barrier_async(consurrentQueue, ^{

long sum=0;

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

sum+=i;

}

NSLog(@"%ld",sum);

});

//不执行完，后面的代码不能执行

dispatch_sync(consurrentQueue, ^{

long sum=0;

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

sum+=i;

}

NSLog(@"sum=%ld",sum);

});

dispatch_async(consurrentQueue, ^{

NSLog(@"2");

});

dispatch_async(consurrentQueue, ^{

NSLog(@"3");

});

//GCD 可以使用此函数，向队列中添加函数，让函数执行.

//函数类型 void (*)(void *)空参无返回值

//第二个参数为函数的参数

dispatch_async_f(consurrentQueue, "string", function);

//dispatch_once_t 添加的任务，在整个程序运行期间只会执行一次(重复添加无效).

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

NSLog(@"hahhhahahah");

});

dispatch_once(&onceToken, ^{

NSLog(@"hahhhahahah");

});

dispatch_once(&onceToken, ^{

NSLog(@"hahhhahahah");

});

//--------------------判断当前队列是否是主队列--------------

dispatch_async(dispatch_get_main_queue(), ^{

//输入当前队列的信息

NSLog(@"%@",[NSThread currentThread]);

//判断是否是主队列

NSLog(@"%d",[NSThread isMainThread]);

});

dispatch_async(consurrentQueue, ^{

//输出当前队列的信息

NSLog(@"%@",[NSThread currentThread]);

//判断是否是主队列

NSLog(@"%d",[NSThread isMainThread]);

});*/

//线程间通信

[self performSelectorInBackground:@selector(subThreadAction) withObject:nil];

//子线程回到主线程

//1. [self performSelectorOnMainThread:@selector(mainThreadAction:) withObject:string waitUntilDone:YES];

//2. dispatch_get_main_queue()

//子线程与子线程通信

//先回到主线程，再到子线程

// @property(atomic,strong)NSString *name;

//括号内必须是对象类型的，否则会失效

//@synchronized(_name)

//setter

// -(void)setName:(NSString *)name{

// @synchronized(_name){ //同步锁，保证同时只有一个线程可以访问对象

// if (_name!=name ) {

// [_name release];

// _name=[name retain];

// }

//getter

// -(NSString *)name{

// @synchronized(_name){

// return [[_name retain]autorease];

// }

}

//子线程方法

-(void)subThreadAction{

NSString *string=@"asdasdas";

//子线程回到主线程

[self performSelectorOnMainThread:@selector(mainThreadAction:) withObject:string waitUntilDone:YES];

}

//主线程方法

-(void)mainThreadAction:(id)sender{

NSLog(@"%@",[NSThread currentThread]);

NSLog(@"%@",sender);

}

- (void)didReceiveMemoryWarning {

[super didReceiveMemoryWarning];

// Dispose of any resources that can be recreated.

}

@end