概述

多线程的本质就是CPU轮流随机分配给每条线程时间片资源执行任务，看起来多条线程同时执行任务。

多条线程同时访问同一块资源，比如操作同一个对象、统一变量、同一个文件，就会引发数据错乱和数据安全的问题。

多线程引发问题实例

这里我也借助网上两个比较经典的案例，卖票和存取钱。

卖票案例

多个线程同时卖票，同一时间多个线层同时访问票的总数，就会引发数据错乱。

实例代码

@interface ViewController ()

@property (nonatomic, assign) int tickets;

@end

@implementation ViewController

- (void)viewDidLoad {

    [super viewDidLoad];

    self.tickets = 30;

    [self saleTicketTest];

}

- (void)saleTicketWithName:(NSString *)name

{

   int currTicketCount = self.tickets;

    sleep(.2);

    currTicketCount--;

    self.tickets = currTicketCount;

    NSLog(@"当前%@卖了一张，票还剩：%d张", name ,self.tickets);

}

- (void)saleTicketTest

{

    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

    dispatch_async(queue, ^{

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

            [self saleTicketWithName:@"A"];

        }

    });

    dispatch_async(queue, ^{

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

            [self saleTicketWithName:@"B"];

        }

    });

    dispatch_async(queue, ^{

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

            [self saleTicketWithName:@"C"];

        }

    });

}

@end

异常结果：

存钱取钱案例

实例代码

#import "ViewController.h"

@interface ViewController ()

@property (nonatomic, assign) int currMoney;

@end

@implementation ViewController

- (void)viewDidLoad {

    [super viewDidLoad];

    self.currMoney = 1000;

    [self moneyTest];

}

- (void)moneyTest

{

    dispatch_async(dispatch_get_global_queue(0, 0), ^{

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

            [self saveMoney];

        }

    });

    dispatch_async(dispatch_get_global_queue(0, 0), ^{

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

            [self drawMoney];

        }

    });

}

// 存钱

- (void)saveMoney

{

    int money = self.currMoney;

    sleep(.3);

    money += 100;

    self.currMoney = money;

    NSLog(@"存了100，还剩%d元", self.currMoney);

}

// 取钱

- (void)drawMoney

{

    int money = self.currMoney;

    sleep(.3);

    money -= 50;

    self.currMoney = money;

    NSLog(@"取了50，还剩%d元", self.currMoney);

}

异常结果：

多线程安全隐患的解决方案

开发中解决多线程安全隐患的方案-使用线程同步技术。同步（协同步调，按预定的先后顺序执行）

常见的线程同步技术就是加锁。

iOS中线程同步的方案根据性能优先级排序：

线程同步的方案	需要导入头文件	类别	注意事项
os_unfair_lock	<os/lock.h>	互斥锁	iOS10才开始提供，用来替代OSSpinLock
OSSpinLock	<libkern/OSAtomic.h>	自旋锁	目前不在安全，可能会出现优先级反转问题
dispatch_semaphore	#import <pthread.h>
pthread_mutex	#import <pthread.h>
dispatch_queue(DISPATCH_SENTINEL)	#import <pthread.h>
NSLock
oNSCondition	#import <os/lock.h>
pthread_mutex(recuresive)	#import <pthread.h>
NSRecursiveLock
NSConditionLock
@synchronized

OSSpinLock

OSSpinLock叫做”自旋锁”，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源。如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁。

需要导入头文件#import <libkern/OSAtomic.h>

os_unfair_lock

os_unfair_lock用于取代不安全的OSSpinLock ，从iOS10开始才支持，从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等。

需要导入头文件#import <os/lock.h>

pthread_mutex

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

需要导入头文件#import <pthread.h>

注意：pthread_mutex在不使用时需要释放锁与属性。

在上面存钱取钱实例通过pthread_mutex实现线程安全。

#import "ViewController.h"

#import <pthread.h>

@interface ViewController ()

@property (nonatomic, assign) int currMoney;

@property (nonatomic, assign) pthread_mutex_t lock;

@property (nonatomic, assign) pthread_mutexattr_t attr;

@end

@implementation ViewController

- (void)viewDidLoad {

    [super viewDidLoad];

    // 初始化属性

//    pthread_mutexattr_t att;

    pthread_mutexattr_init(&_attr);

    // 设置锁的类型

    pthread_mutexattr_settype(& _attr, PTHREAD_MUTEX_DEFAULT);

    // 初始化lock

    pthread_mutex_init(&_lock, & _attr);

    self.currMoney = 1000;

    [self moneyTest];

}

- (void)dealloc

{

    pthread_mutex_destroy(& _lock);

    pthread_mutexattr_destroy(&_attr);

}

- (void)moneyTest

{

    dispatch_async(dispatch_get_global_queue(0, 0), ^{

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

            [self saveMoney];

        }

    });

    dispatch_async(dispatch_get_global_queue(0, 0), ^{

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

            [self drawMoney];

        }

    });

}

// 存钱

- (void)saveMoney

{

    pthread_mutex_lock(& _lock);

    int money = self.currMoney;

    sleep(.3);

    money += 100;

    self.currMoney = money;

    NSLog(@"存了100，还剩%d元", self.currMoney);

    pthread_mutex_unlock(& _lock);

}

// 取钱

- (void)drawMoney

{

    pthread_mutex_lock(& _lock);

    int money = self.currMoney;

    sleep(.3);

    money -= 50;

    self.currMoney = money;

    NSLog(@"取了50，还剩%d元", self.currMoney);

    pthread_mutex_unlock(& _lock);

}

pthread_mutex – 递归锁

递归锁的特点：允许同一个线程对同一把锁进行重复加锁，这里强调的是同一个线程。

递归锁在是使用场合是什么呢？

方法嵌套

- (void)test1

{

    pthread_mutex_lock(&_lock);

    NSLog(@"任务1");

    [self test2];

    pthread_mutex_unlock(&_lock);

}

- (void)test2

{

    pthread_mutex_lock(&_lock);

    NSLog(@"任务2");

    pthread_mutex_unlock(&_lock);

}

递归

- (void)test1

{

    pthread_mutex_lock(&_lock);

    NSLog(@"任务1");

    [self test1];

    pthread_mutex_unlock(&_lock);

}

pthread_mutex – 条件锁

多线程任务执行是没有顺序的，比如现在想实现一个消费者模式的多线程案例

当有生产者产出数据是才需要让消费者获取数据执行逻辑。由于生产与消费是多线程，可以在消费逻辑中加入判断，当没有数据时让消费线程休眠释放锁，生产者线程获取锁执行生产，当生产者有数据时发送信号通知消费者线程，消费者线程唤醒并重新再次加锁。

这是就需要用pthread_mutex条件锁。

实例代码

#import "ViewController.h"

#import <pthread.h>

@interface ViewController ()

@property (nonatomic, assign) pthread_mutex_t lock;

@property (nonatomic, assign) pthread_cond_t condition;

@property (nonatomic, strong) NSMutableArray *array;

@end

@implementation ViewController

- (void)viewDidLoad {

    [super viewDidLoad];

    self.array = [NSMutableArray array];

    // 传入NUll 使用PTHREAD_MUTEX_DEFAULT类型的锁

    pthread_mutex_init(&_lock, NULL);

    pthread_cond_init(&_condition, NULL);

    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        [self remove];

    });

    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        [self add];

    });

}

// 删除数组中的元素

- (void)remove

{

    pthread_mutex_lock(&_lock);

    if (self.array.count == 0) {

        // 执行wait 当前线层进入休眠，放开mutex锁，被唤醒后对mutex再次加锁

        pthread_cond_wait(&_condition, &_lock);

    }

    NSLog(@"删除了元素");

    [self.array removeLastObject];

    pthread_mutex_unlock(&_lock);

}

// 往数组添加元素

- (void)add

{

    pthread_mutex_lock(&_lock);

    [self.array addObject:@"test"];

    // 发送信号 激活等待该条件的线程

    pthread_cond_signal(&_condition);

    // 广播 激活所有等待该条件的线程

//    pthread_cond_broadcast(&_condition);

    NSLog(@"添加了元素");

    pthread_mutex_unlock(&_lock);

}

NSLock NSRecursiveLock

NSLock是对mutex普通锁的封装。遵守了协议。

NSRecursiveLock也是对mutex递归锁的封装，API跟NSLock基本一致

NSCondition

NSCondition是对mutex和cond的封装。

实例代码

#import "ViewController.h"

@interface ViewController ()

@property (nonatomic, strong) NSMutableArray *array;

@property (nonatomic, strong) NSCondition *condition;

@end

@implementation ViewController

- (void)viewDidLoad {

    [super viewDidLoad];

    self.array = [NSMutableArray array];

     self.condition = [[NSCondition alloc] init];

    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        [self remove];

    });

    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        [self add];

    });

}

// 删除数组中的元素

- (void)remove

{

//    pthread_mutex_lock(&_lock);

    [self.condition lock];

    if (self.array.count == 0) {

        // 执行wait 当前线层进入休眠，放开mutex锁，被唤醒后对mutex再次加锁

        [self.condition wait];

    }

    NSLog(@"删除了元素");

    [self.array removeLastObject];

    [self.condition unlock];

//    pthread_mutex_unlock(&_lock);

}

// 往数组添加元素

- (void)add

{

//    pthread_mutex_lock(&_lock);

    [self.condition lock];

    [self.array addObject:@"test"];

    // 发送信号 激活等待该条件的线程

    [self.condition signal];

    // 广播 激活所有等待该条件的线程

    [self.condition broadcast];

    NSLog(@"添加了元素");

    [self.condition unlock];

//    pthread_mutex_unlock(&_lock);

}

NSConditionLock

NSConditionLock是对NSCondition的进一步封装，可以设置具体的条件值。可以让子线程按着指定的顺序执行。

示例代码：

dispatch_semaphore 信号量

semaphore叫做”信号量”。信号量的初始值，可以用来控制线程并发访问的最大数量。信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步。

dispatch_queue串行队列

直接使用GCD的串行队列，也是可以实现线程同步的

@synchronized

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

巴特西

iOS开发系列-线程同步技术

概述

多线程引发问题实例

卖票案例

存钱取钱案例

多线程安全隐患的解决方案

OSSpinLock

os_unfair_lock

pthread_mutex

pthread_mutex – 递归锁

方法嵌套

递归

pthread_mutex – 条件锁

NSLock NSRecursiveLock

NSCondition

NSConditionLock

dispatch_semaphore 信号量

dispatch_queue串行队列

@synchronized

最新文章

热门文章