1. 多线程技术
1). NSThread :
1. 使用NSThread对象建立一个线程非常方便;
2. 但是!要使用NSThread管理多个线程非常困难,不推荐使用;
3. 技巧!使用[NSThread currentThread]跟踪任务所在线程,适用于这三种技术.
NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(threadRun) object:nil];
[thread setName:@"first"];
[thread start];
2). NSOperation:
1.提供了一些在GCD中不容易实现的特性,如:限制最大并发数量,操作之间的依赖关系.
2.NSOperation有状态返回，能控制其取消等操作,推荐使用多线程的时候用这种方式，灵活
NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(runInvocationOperation) object:nil];
[invocationOperation setQueuePriority:NSOperationQueuePriorityVeryHigh];
NSInvocationOperation *invocationOperation1 = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(runInvocationOperation) object:nil];
[invocationOperation1 setQueuePriority:NSOperationQueuePriorityLow];
[invocationOperation1 addDependency:invocationOperation];//增加依赖，某个任务完成，才开始这个任务
[invocationOperation cancel];//取消动作
[invocationOperation start];//开始动作
BOOL isExe = invocationOperation.isExecuting;//是否执行中
BOOL isFinish = invocationOperation.isFinished;//是否结束了
self.queue = [[NSOperationQueue alloc]init];
[self.queue setMaxConcurrentOperationCount:2];
[self.queue addOperation:invocationOperation];
[self.queue addOperation:invocationOperation1];
3). GCD
- 操作使用Blocks定义;
- 队列负责调度任务执行所在的线程以及具体的执行时间;
- 队列的特点是先进先出(FIFO)的,新添加至队列的操作都会排在队尾.
- 简单用法：
dispatch_queue_t serialQueue = dispatch_queue_create("com.cc", nil);//串行分发队列
dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);//并发分发队列
dispatch_queue_t mainQueue = dispatch_get_main_queue();//主分发队列 主线程
//dispatch_async异步执行
dispatch_async(mainQueue, ^{
[NSThread sleepForTimeInterval:5];
});
//dispatch_sync阻塞执行
dispatch_sync(mainQueue, ^{
[NSThread sleepForTimeInterval:5];
});//这样会死锁主线程 dispatch_sync等待block执行完，block需要在主线程中运行，相互死锁
//2.gcd group用法
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, concurrentQueue, ^{
//
});
dispatch_group_async(group, concurrentQueue, ^{
});
dispatch_group_notify(group, mainQueue, ^{
//group执行完后
});
- 其他用处：
信号量dispatch semaphore
dispatch_semaphore_create(1);//创建一个初始信号量为1的semaphore
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);//等待信号量大于0，时间：永远
dispatch_semaphore_signal(semaphore);//释放一个资源，使信号量加1
分发栅栏dispatch barrier
dispatch_barrier_async(queue, ^{
});//作用等待queue里面的操作完成后进行block操作
分发源dispatch source
监听指定的各种事件
变量增加dispatch_source_type_data_add
变量OR dispatch_source_type_data_or
进程相关dispatch_source_type_proc
文件读写
.......
4). 使用performSelecter
//在当前线程运行
[self performSelector:@selector(threadRun) withObject:nil afterDelay:1.0];
//在指定线程运行
[self performSelector:@selector(threadRun) onThread:[NSThread currentThread] withObject:nil waitUntilDone:YES];
//在后台线程运行
[self performSelectorInBackground:@selector(threadRun) withObject:nil];
//在主线程运行
[self performSelectorOnMainThread:@selector(threadRun) withObject:nil waitUntilDone:YES];
5). 使用pthread创建线程
- (void)launchPthread{
pthread_attr_t attr;
pthread_t posixThreadID;
int returnVal;
returnVal = pthread_attr_init(&attr);
assert(!returnVal);
returnVal = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
assert(!returnVal);
int threadError = pthread_create(&posixThreadID, &attr, &PosixThreadMainRoutine, NULL);
returnVal = pthread_attr_destroy(&attr);
assert(!returnVal);
if (threadError != 0)
{
}
}
void *PosixThreadMainRoutine(void * data){
NSLog(@"dosomething");
return NULL;
}
2. 线程数据安全
1). nonatomic atomic
使用atomic多线程原子性控制，atomic的原理给setter加上锁，getter不会加锁
@property (atomic,assign) NSInteger leftTicketsCount;
//默认有10张票
self.leftTicketsCount=10;
//开启多个线程，模拟售票员售票
self.thread1=[[NSThread alloc]initWithTarget:self selector:@selector(sellTickets) object:nil];
self.thread1.name=@"售票员A";
self.thread2=[[NSThread alloc]initWithTarget:self selector:@selector(sellTickets) object:nil];
self.thread2.name=@"售票员B";
self.thread3=[[NSThread alloc]initWithTarget:self selector:@selector(sellTickets) object:nil];
self.thread3.name=@"售票员C";
[self.thread1 start];
[self.thread2 start];
[self.thread3 start];
-(void)sellTickets
{
while (true) {
if (self.leftTicketsCount > 0 ) {
[NSThread sleepForTimeInterval:0.5];
self.leftTicketsCount--;
NSLog(@"thread:%@ ---> %ld",[[NSThread currentThread] name],self.leftTicketsCount);
}
else{
break;
}
}
}
输出.png
读取写入并行发生的时候，会出现如上错误
2). 使用GCD实现atomic操作：
给某字段的setter和getter方法加上同步队列：
- (void)setCount:(NSInteger)newcount{
dispatch_sync(_synQueue, ^{
count = newcount;
});
}
- (NSInteger)count{
__block NSInteger localCount;
dispatch_sync(_synQueue, ^{
localCount = count;
});
return localCount;
}
gcd添加原子性.png
3). 使用NSLock
_lock = [[NSLock alloc]init];
- (void)threadRunLock{
while (true) {
[_lock lock];
if (self.number > 0 ) {
[NSThread sleepForTimeInterval:0.5];
self.number --;
NSLog(@"thread:%@ ---> %ld",[[NSThread currentThread] name],self.number);
}
[_lock unlock];
}
}
相当于给代码片段加上lock了，所以依次输出9-0
iOS系统提供了三种锁
1.NSLock
2.NSConditionLock;条件锁 －－－ 条件锁是一个互斥锁，可以通过特定值来锁住和解锁
3.NSRecursiveLock;递归锁 －－－ 对同一线程，可以多次获得（lock）而不会造成死锁
在unix中，提供POSIX thread lock：
pthread_mutex_t mutex;//互斥锁
pthread_rwlock_t lock;//读写锁
pthread_condattr_t conLock;//条件锁
点击这里查看
4). 使用GCD的信号量和栅栏
在使用一些特殊三方库的时候，例如七牛上传，需要进行异步并发操作，但是七牛自己会有一个下载队列，并且开发者不能获取到这个队列，那么在我们需要设置自己的并发数就会有问题（...）
使用信号量可以很方便的解决该问题：
dispatch_semaphore_create(max);//创建一个初始信号量为max的semaphore
然后在队列添加任务的时候
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);//等待信号量大于0，时间：永远
有资源可以使用的时候往下继续
addOpeartion...
在成功或者失败返回的时候
dispatch_semaphore_signal(semaphore);//释放一个资源，使信号量加1
栏栅：
在前面队列执行完成之后执行该操作，简单用法有点像读写锁
总结
目前大概会用到的多线程除了pthread应该都是必须掌握的，线程安全使用原子性（atomic）、NSLock、volatile和信号量比较常用
