多线程

The term thread is used to refer to a separate path of execution for code.//线程用于指代一个独立执行的代码路径

The term process is used to refer to a running executable, which can encompass multiple threads.//进程用于指代一个可执行文件,它可以拥有多个线程

当一个可执行程序中拥有多个独立执行的代码路径的时候，这就叫做多线程，操作系统的基础知识告诉我们，线程，是执行程序最基本的单元，它有自己栈和寄存器。说得再具体一些，线程就是“一个CPU执行的一条无分叉的命令列”。

同步:就是协同步调，按预定的先后次序进行

dispatch_sync和dispatch_async用来控制是否要开启新的线程

1.在当前线程中执行任务，不具备开启新线程的能力，

2.dispatch_sync立马在当前线程同步执行任务

异步：

1.在新的线程中执行任务，具备开启新线程的能力

2.dispatch_async不要求立马在当前线程同步执行任务

    dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_CONCURRENT);

     dispatch_async(queue, ^{ // 0
         NSLog(@"执行任务1--- %@",[NSThread currentThread]);
        dispatch_sync(queue, ^{ // 在当前线程执行,并不会产生新的线程
         NSLog(@"执行任务2--- %@",[NSThread currentThread]);
        });
    });
//打印结果
执行任务1--- <NSThread: 0x60000046c440>{number = 3, name = (null)}
执行任务2--- <NSThread: 0x60000046c440>{number = 3, name = (null)}

    dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{ // 0
        NSLog(@"执行任务1");
        
        dispatch_sync(queue, ^{ // 会产生死锁,在同一个串行队列中,任务1未完成,插入了任务2
            NSLog(@"执行任务2");
        });
    
        NSLog(@"执行任务3");
    });

- (void)test
{
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{  //会产生死锁
        NSLog(@"执行任务2");
    });
 }

使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列（产生死锁）

队列的并发和串行影响：任务的执行方式

并发：多个任务并发（同时）执行

串行：一个任务执行完毕后，再执行下一个任务，主队列也是一个串行队列

各种队列的执行效果.png

队列组的使用

如何用gcd实现以下功能

异步并发执行任务1、任务2

等任务1、任务2都执行完毕后，再回到主线程执行任务3

队列组的使用.png

多线程的安全隐患

1块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源,比如多个线程访问同一个对象、同一个变量、同一个文件,当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题

自旋锁

OSSpinLock叫做”自旋锁”，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源，目前已经不再安全，可能会出现优先级反转问题

如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁

//self.lock = OS_SPINLOCK_INIT; //初始化一把锁
-(void)test{
     // 加锁
    OSSpinLockLock(&_lock);
    
    //code 操作变量,修改数据操作
    
    // 解锁
    OSSpinLockUnlock(&_lock);
}

从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等

mutex叫做”互斥锁”，等待锁的线程会处于休眠状态

dispatch_semaphore

1.信号量的初始值，可以用来控制线程并发访问的最大数量

2.信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步

@synchronized

@synchronized是对mutex递归锁的封装

@synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作

什么情况使用自旋锁比较划算？

1.预计线程等待锁的时间很短
2.CPU资源不紧张,多核处理器

什么情况使用互斥锁比较划算？

1.预计线程等待锁的时间较长
2.单核处理器

atomic

1.atomic用于保证属性setter、getter的原子性操作，相当于在getter和setter内部加了线程同步的锁

2.它并不能保证使用属性的过程是线程安全的,比如访问成员变量

同一时间“多读单写”，经常用于文件等数据的读写操作，iOS中的实现方案有

1.pthread_rwlock：读写锁

/*****************pthread_rwlock_t********************/

@property (assign, nonatomic) pthread_rwlock_t lock;
 // 初始化锁
 pthread_rwlock_init(&_lock, NULL);

- (void)read {
    pthread_rwlock_rdlock(&_lock);
    
    sleep(1);
    NSLog(@"%s", __func__);
    
    pthread_rwlock_unlock(&_lock);
}

- (void)write
{
    pthread_rwlock_wrlock(&_lock);
    
    sleep(1);
    NSLog(@"%s", __func__);
    
    pthread_rwlock_unlock(&_lock);
}

- (void)dealloc
{
    pthread_rwlock_destroy(&_lock);
}

2.dispatch_barrier_async：异步栅栏调用

dispatch_barrier_async

1.这个函数传入的并发队列必须是自己通过dispatch_queue_cretate创建的
2.如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果

//dispatch_barrier_async
- (void)read {
    dispatch_async(self.queue, ^{
        sleep(1);
        NSLog(@"read");
    });
}

- (void)write
{
    dispatch_barrier_async(self.queue, ^{
        sleep(1);
        NSLog(@"write");
    });
}

OS_UNFAIR_LOCK

Lock = OS_UNFAIR_LOCK_INIT;

// 死锁：永远拿不到锁
- (void)__saleTicket
{
    os_unfair_lock_lock(&Lock);  //性能最好的锁
    //code 
    os_unfair_lock_unlock(&Lock);
}

递归锁：允许同一个线程对一把锁进行重复加锁

    // 初始化属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    // 初始化锁
    pthread_mutex_init(mutex, &attr);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);


- (void)otherTest
{
    pthread_mutex_lock(&_mutex);
    
    static int count = 0;
    if (count < 10) {
        count++;
        [self otherTest];
    }
    
    pthread_mutex_unlock(&_mutex);
}

线程中的生产者——消费者模式

// 删除数组中的元素
- (void)__remove
{
    pthread_mutex_lock(&_mutex);
    
    if (self.data.count == 0) {
        // 等待
        pthread_cond_wait(&_cond, &_mutex);  //进入休眠,释放锁
    }
    
    [self.data removeLastObject];
    
    pthread_mutex_unlock(&_mutex);
}

// 线程2
// 往数组中添加元素
- (void)__add
{
    pthread_mutex_lock(&_mutex);
    sleep(1);

    [self.data addObject:@"Test"];
    // 信号
    pthread_cond_signal(&_cond);  //唤醒休眠线程
    // 广播
//    pthread_cond_broadcast(&_cond);
    
    pthread_mutex_unlock(&_mutex);
}

通过NSConditionLock控制各个线程的执行顺序

- (void)__one
{
    [self.conditionLock lock];
    
    NSLog(@"__one");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:2];
}

- (void)__two
{
    [self.conditionLock lockWhenCondition:2];
    
    NSLog(@"__two");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:3];
}

使用信号量控制线程的执行

@property (strong, nonatomic) dispatch_semaphore_t ticketSemaphore;

- (instancetype)init
{
    if (self = [super init]) {
        self.semaphore = dispatch_semaphore_create(5); //并发量是5
        self.ticketSemaphore = dispatch_semaphore_create(1);
    }
    return self;
}

- (void)test
{
    // 如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
    // 如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    
    // 让信号量的值+1
    dispatch_semaphore_signal(self.semaphore);
}

synchronized的使用

- (void)Test
{
    @synchronized([self class]) { 
        [self Test];
    }
}

初始化可以长期接收消息的线程

- (void)threadMain {
    [[NSThread currentThread] setName:@"myThread"]; // ①给线程设置名字
    NSRunLoop *runLoop = [NSRunLoop currentRunLoop];    // ②给线程添加runloop
    [runLoop addPort:[NSMachPort port] forMode:NSDefaultRunLoopMode];   //③给runloop添加数据源
    while (![[NSThread currentThread] isCancelled]) {           //④：检查isCancelled
        [runLoop runMode:NSDefaultRunLoopMode beforeDate:[NSDate dateWithTimeIntervalSinceNow:10]];  //⑤启动runloop
    }
}

结束线程

- (void)cancelThread
{
    [[NSThread currentThread] cancel];
    CFRunLoopStop(CFRunLoopGetCurrent());
}

dispatch_group

let group = dispatch_group_create()

dispatch_group_async(group, serialQueue, { () -> Void in  
    for _ in 0..<2 {
        print("group-serial \(NSThread.currentThread())")
    }
})

dispatch_group_async(group, serialQueue, { () -> Void in  
    for _ in 0..<3 {
        NSLog("group-02 - %@", NSThread.currentThread())
    }
})

dispatch_group_notify(group, serialQueue, { () -> Void in  
    print("完成 - \(NSThread.currentThread())")
})

dispatch_group_notify这个方法表示把第三个参数block传入第二个参数队列中去。而且可以保证第三个参数block执行时，group中的所有任务已经全部完成。

dispatch_group_wait(group: dispatch_group_t, _ timeout: dispatch_time_t) -> Int第一个参数表示要等待的group，第二个则表示等待时间。返回值表示经过指定的等待时间，属于这个group的任务是否已经全部执行完，如果是则返回0，否则返回非0。

第二个dispatch_time_t类型的参数还有两个特殊值：DISPATCH_TIME_NOW和DISPATCH_TIME_FOREVER。前者表示立刻检查属于这个group的任务是否已经完成，后者则表示一直等到属于这个group的任务全部完成。

dispatch_source_t

dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);  
dispatch_source_set_timer(timer, dispatch_walltime(NULL, 0), 10*NSEC_PER_SEC, 1*NSEC_PER_SEC); //每10秒触发timer，误差1秒  
dispatch_source_set_event_handler(timer, ^{  
    // 定时器触发时执行的 block
});
dispatch_resume(timer);  

使用 GCD Timer 的好处在于不依赖 runloop，因此任何线程都可以使用。由于使用了 block，不会忘记避免循环引用。此外，定时器可以自由控制精度，随时修改间隔时间等。

参考资料:iOS多线程编程总结