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

GCD 常用API

主行列:dispatch_get_main_queue()
  1. 专门用来在主线程上调度使命的行列
  2. 不会开端线程
  3. 假如当时主线程正在由使命履行,那么不管主行列中当时被增加了什么使命,都不会被调度
  4. 能够理解为串行行列(serial),但是它的行为并不完全像惯例的串行行列
  5. 在main()函数创立之前就有主行列了
大局行列:
  1. 为了方便程序员的运用,苹果供给了大局行列:dispatch_get_global_queue(0, 0)
  2. 大局行列是一个并发行列(concurrent)
  3. 在运用多线程开发时,假如对行列没有特别需求,在履行异步使命时,能够直接运用大局行列

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. 多个线程一起访问一块内存
  2. 引发数据错乱和

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

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 操作 多读 单写

  1. 从文件中 读取内容

  2. 往文件中写入内容

要求

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

计划一 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 基础 多线程