oc 基础多线程-六虎

pthread c 言语
NSthread
GDC 充分利用多核
NSOperation

GCD 常用API

主行列:dispatch_get_main_queue()

专门用来在主线程上调度使命的行列
不会开端线程
假如当时主线程正在由使命履行,那么不管主行列中当时被增加了什么使命,都不会被调度
能够理解为串行行列(serial),但是它的行为并不完全像惯例的串行行列
在main()函数创立之前就有主行列了

大局行列:

为了方便程序员的运用,苹果供给了大局行列:dispatch_get_global_queue(0, 0)
大局行列是一个并发行列(concurrent)
在运用多线程开发时,假如对行列没有特别需求,在履行异步使命时,能够直接运用大局行列

dispath_sync
在当时的线程中履行使命

dispath_async
在新的线程中履行使命,不一定能够开启新的线程

并发多个使命一起履行
串行一个爱一个履行

主行列是一种特别的串行行列

同步一定是串行履行,因为只要一个线程

只要异步 + 并发行列才会并发履行使命

死锁问题

状况 1

viewDidload {
nslog (1)
dispath_sync (getmainqueue, ^{
nsllog(2);
})
nslog(3)
}

行列的特色排队先进先出 FIFO

并发履行使命一恣意二之后履行使命3

运用使命组

gispath_group_t group = dispath_group_create();

创立并发行列

diapath_queue queue = dispath_queue (CONCURRENT);

增加异步使命运用 group 函数

dispath_group_async (group, queueu, ^{
nslog(1)
})
dispath_group_async (group, queueu, ^{
nslog(2)
})’
// 唤醒
dispath_group_notify(group,queue, ^{
nslog(3)
})

dispath_group_notify(group,queue, ^{
nslog(4)
})

34 会交替履行

dispath_group_notify(group,get_main_queue, ^{
nslog(4)
})

多线程的安全隐患

多个线程一起访问一块内存
引发数据错乱和

运用线程同步技术解决问题

1 桎梏

iOS 中有这9种锁

小心死锁问题

OSSpinkLock (高级锁)

自旋锁一向占用资源,盲等, 不安全或许呈现优先级回转

优先级回转 :

thread1 10ms 高
thread2 10ms 底
thread3 10ms
线程的调度每个线程分配时刻片多线程的原理

优先级高的话时刻给的会多一点

假如 2 桎梏 , 1 假如看到2 加锁会等候2 , 一向分配时刻给 1

thread2 没有时刻或许导致不履行

{
#improt <os/lock.h>
OSSpinkLock *lock = OS_Spink_init; ios10 现已过期

}

os_unfair_loack fair(公平) 低级锁, 等不到就休眠
替代 osspinklock
加锁的线程处于休眠状况

pthread_mutex

mutex 互斥锁等候的或线程会休眠

{
#import <pthread.h>
@property (nonatomic) pthread_mutex mutex;
//静态初始化
pthread_mutex = PETHEAD_MUTEX_INITAILIZE;
//初始化特点
pthread_mutext_attr_t attr;
pthread_mutet_settype(&attr, PTHREAD_MUTEXT_NORMAL)
{
#define PTHREAD_MUTEXT_NORMAL 0
#define PTHREAD_MUTEXT_ERRORCHECK 1
#define PTHREAD_MUTEXT_RECURSIVE 2 递归锁
#define PTHREAD_MUTEXT_DEFAULT

}
// 设置特点

//初始化锁

pthread_mutext_init(&mutex,attr);

// 销毁锁

pthread_mutex_destory(&att)

// 初始化条件

pthread_cond_t = condition;

pthread_cond_init(&condition)

RECURSIVE 递归所允许同一个线程重复加锁

(void)test {
pthread_mutext_lock(&mutext);
```
  [self test];
  pthread_mutext_unlock(&mutext);
```
}
// 删去数组中元素
- (void)test2 {
  
  pthread_mutext_lock(&mutext);
  
  [self test];
  
  pthread_mutext_unlock(&mutext);
}
- (void)__remode {
  pthread_mutext_lock(&mutext);
  
  if (array.count == 0) {
  //到达条件后让线程等候所以是条件锁
  使用场景线程 1 依赖线程 2 ;
  生产者 — 顾客模式
  pthread_cond_wait(&cond,&mutext);
  }
  
  [array removeObjc];
  
  pthread_mutext_unlock(&mutext);
  }
- (void)__add {
  pthread_mutext_lock(&mutext);
  
  [array addObjc];
  // 发送信号结束等候
  pthread_cond_signal(&cond);
  // 发播送,多个 wait 一起能收到
  pthread_cond_broadcast(&cond);
  
  pthread_mutext_unlock(&mutext);
  }
  }

dispath_semaphore

// 能够操控对打并发线程数量

{
信号量的初始值是1
diapath_semaphor_t semaphore = dispath+semaphore_create(value)
// 假如信号量小于等于 0 就进入休眠等候
// 假如信号量的值大约 0 就-1 然后往下履行后边的代码
diapath_memaphore_wait(semaphor,DISPATH_TIME_FOREVER);

 // 让信号量的值 加一
 dispatch_semaphore_signal(smaphore)

}

dispath_queue(SERIAL)

NSLock // 对 pthread defoult 的封装

NSRecurisiveLock // 对 pthread Recurisive 的封装

NSCondition // 对 pthread mutex 和 con 的封装

NSConditionLock 对 NSCondition 进一步的封装能够对条件设置值

能够设置线程之间的依赖

{
self.conditionLock = [NSCondition alloc]initWidthCondition:1];

 - (void)test {
     [NSthread alloc] initWidthTarget: self selector:@selector(__one) object start];
     [NSthread alloc] initWidthTarget: self selector:@selector(__two) object start];
     [NSthread alloc] initWidthTarget: self selector:@selector(__three) object start];
     - (void)__one {
         [self.conditionLock lockWhenCondition:1];
         nslog(11);
         [self.conditionLock unlockWhenCondition:1];
     }
     - (void)__two {
         [self.conditionLock lockWhenCondition:2];
         nslog(22);
         [self.conditionLock unlockWhenCondition:3];
     }
     - (void)__three {
         [self.conditionLock lockWhenCondition:3];
         nslog(33);
         [self.conditionLock unlock];
     }
 }

}

@synchronized // 相当于对 pthread mutex 递归锁的封装

{
– (void)test{
@synchronized ([self class]) {
self class 的唯一性成为同一把锁的关键
}
@synchronized (self) {
nslog(11)
}
}

}

IO 操作多读单写

从文件中读取内容
往文件中写入内容

要求

同一时刻只能有一个线程写的操作
同一时刻允许有多个读的操作
同一时刻不允许既有写的操作,又有读的操作

计划一 pthread_rwlock 读写锁

计划二 dispath_barrier_async : 异步栅门函数

pthread_rwlock


//初始化锁
    pthread_rwlock_t lock
    pthread_rwlock_init(&lock,BULL)
    // 读取加锁
    pthread_rwlock_rdlock(&lock)
    //写加锁
    pthread_rwlock_wrlock(&lock)
    //解锁
    pthread_rwlock_unlock(&lock)
    //销毁
    pthread_rwlock_destory

oc 基础 多线程

主行列:dispatch_get_main_queue()

大局行列:

相关文章

「杂谈」认真聊聊写博客这件事

iOS老司机的接地气算法Tips

前端程序员搭建自己的CodeIDE（code-server教程）

Android 线程优化插件使用（第一篇）

作者信息

oc 基础多线程