iOS 线程同步（加锁）的方案

最新推荐文章于 2024-06-09 13:54:04 发布
最新推荐文章于 2024-06-09 13:54:04 发布
阅读量587 收藏
点赞数
分类专栏： OC学习小记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyz0925/article/details/108993975
版权

OSSpinLock

OSSpinLock叫做“自旋锁”， 等待锁的线程会处于忙等状态，一直占用着CPU资源。

  • 缺点：目前已经不再安全，可能会出现优先级反转问题。

如果等待锁的线程优先级较高，它会一直占用CPU资源，优先级低的线程就无法释放锁。
例如，有两个贤臣：
thread1 （优先级比较高）
thread2 （优先级比较低）
thread2 先用OSSpinLock加锁，此时thread1 进来，一看代码已经被加锁。那么此时，优先级高的线程会一直判断是否加锁；
如果加锁了，就继续一直判断，那么CPU就会一直被优先级高的thread1的线程占用着；
优先级比较低的thread2 的锁就没有时间处理 解锁；然后就会卡死。

  • OSSpinLock的常用方法如下：
	//导入头文件：#import <libkern/OSAtomic.h>
    //初始化
    OSSpinLock lock = OS_SPINLOCK_INIT;
    //尝试加锁(如果需要等待就不加锁，返回false，如果不需要等待就加锁，返回true)
    BOOL result = OSSpinLockTry(&lock);
    //加锁
    OSSpinLockLock(&lock);
    //解锁
    OSSpinLockUnlock(&lock);
  • OSSpinLock的使用demo如下：
#import "ViewController.h"
#import <libkern/OSAtomic.h>

@interface ViewController ()
@property (assign, nonatomic) int money;
@property (assign, nonatomic) int ticketsCount;
@property (assign, nonatomic) OSSpinLock lock;
@property (assign, nonatomic) OSSpinLock lock1;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    self.lock = OS_SPINLOCK_INIT;
    self.lock1 = OS_SPINLOCK_INIT;
    
    [self ticketTest];
    [self moneyTest];
}

/**
 存钱、取钱演示
 */
- (void)moneyTest
{
    self.money = 100;
    
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 10; i++) {
            [self saveMoney];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 10; i++) {
            [self drawMoney];
        }
    });
}

/**
 存钱
 */
- (void)saveMoney
{
    // 加锁
    OSSpinLockLock(&_lock1);
    
    int oldMoney = self.money;
    sleep(.2);
    oldMoney += 50;
    self.money = oldMoney;
    
    NSLog(@"存50，还剩%d元 - %@", oldMoney, [NSThread currentThread]);
    
    // 解锁
    OSSpinLockUnlock(&_lock1);
}

/**
 取钱
 */
- (void)drawMoney
{
    // 加锁
    OSSpinLockLock(&_lock1);
    
    int oldMoney = self.money;
    sleep(.2);
    oldMoney -= 20;
    self.money = oldMoney;
    
    NSLog(@"取20，还剩%d元 - %@", oldMoney, [NSThread currentThread]);
    // 解锁
    OSSpinLockUnlock(&_lock1);
}

/**
 卖1张票
 */
- (void)saleTicket
{
    // 加锁
    OSSpinLockLock(&_lock);

    int oldTicketsCount = self.ticketsCount;
    sleep(.2);
    oldTicketsCount--;
    self.ticketsCount = oldTicketsCount;
    NSLog(@"还剩%d张票 - %@", oldTicketsCount, [NSThread currentThread]);
    
    // 解锁
    OSSpinLockUnlock(&_lock);
}

/**
 卖票演示
 */
- (void)ticketTest
{
    self.ticketsCount = 15;
    
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            [self saleTicket];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            [self saleTicket];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            [self saleTicket];
        }
    });
}

os_unfair_lock

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

  • os_unfair_lock的常用方法如下：
	//需要导入头文件#import <os/lock.h>
    //初始化
    os_unfair_lock lock = OS_UNFAIR_LOCK_INIT;
    //尝试加锁
    BOOL result = os_unfair_lock_trylock(&lock);
    //加锁
    os_unfair_lock_lock(&lock);
    //解锁
    os_unfair_lock_unlock(&lock);
  • os_unfair_lock 使用如下：
- (void)__saleTicket
{
    os_unfair_lock_lock(&_ticketLock);
    //__saleTicket 父类写了里面的逻辑
    [super __saleTicket];
    
    os_unfair_lock_unlock(&_ticketLock);
}

pthread_mutex

mutex叫做”互斥锁”，等待锁的线程会处于休眠状态; 需要导入头文件#import <pthread.h>。

  • mutex的使用方法：
	// 静态初始化:初始化的一种，一般不推荐
    pthread_mutex_t mutex_one = PTHREAD_MUTEX_INITIALIZER;
    
    // 初始化属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    /*
     PTHREAD_MUTEX_DEFAULT：表示pthead_mutex 是互斥锁 == PTHREAD_MUTEX_NORMAL
     PTHREAD_MUTEX_RECURSIVE：表示是递归所
     */
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
    // 初始化锁
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, &attr);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);
    //尝试加锁
    pthread_mutex_trylock(&mutex);
    //加锁
    pthread_mutex_lock(&mutex);
    //解锁
    pthread_mutex_unlock(&mutex);
    //销毁锁
    pthread_mutex_destroy(&mutex);

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

代码的使用：

#import <pthread.h>

@interface MutexDemo()
@property (assign, nonatomic) pthread_mutex_t ticketMutex;
@property (assign, nonatomic) pthread_mutex_t moneyMutex;
@end

@implementation MutexDemo

- (void)__initMutex:(pthread_mutex_t *)mutex
{
    // 初始化属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
    // 初始化锁
    pthread_mutex_init(mutex, &attr);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);
}

- (instancetype)init
{
    if (self = [super init]) {
        [self __initMutex:&_ticketMutex];
        [self __initMutex:&_moneyMutex];
    }
    return self;
}

// 死锁：永远拿不到锁
- (void)__saleTicket
{
    pthread_mutex_lock(&_ticketMutex);
    
    [super __saleTicket];
    
    pthread_mutex_unlock(&_ticketMutex);
}

- (void)__saveMoney
{
    pthread_mutex_lock(&_moneyMutex);
    
    [super __saveMoney];
    
    pthread_mutex_unlock(&_moneyMutex);
}

- (void)__drawMoney
{
    pthread_mutex_lock(&_moneyMutex);
    
    [super __drawMoney];
    
    pthread_mutex_unlock(&_moneyMutex);
}

- (void)dealloc
{
    pthread_mutex_destroy(&_moneyMutex);
    pthread_mutex_destroy(&_ticketMutex);
}

@end

pthread_mutex --条件锁

pthread_mutex是可以是互斥锁，也可以是递归所；同时也可以是条件锁。
pthread_mutex作为条件锁的使用如下：

// 初始化属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
// 初始化锁
pthread_mutex_init(&_mutex, &attr);
// 销毁属性
pthread_mutexattr_destroy(&attr);       
// 初始化条件
pthread_cond_init(&_cond, NULL);
//加锁
pthread_mutex_lock(&_mutex);
//等待锁
pthread_cond_wait(&_cond, &_mutex);
//发送条件信号，接触等待
pthread_cond_signal(&_cond);
//解锁
pthread_mutex_unlock(&_mutex);
//销毁锁和销毁条件
pthread_mutex_destroy(&_mutex);
pthread_cond_destroy(&_cond);

使用案例如下：

#import <pthread.h>

@interface MutexDemo3()
//锁
@property (assign, nonatomic) pthread_mutex_t mutex;
//条件
@property (assign, nonatomic) pthread_cond_t cond;
@property (strong, nonatomic) NSMutableArray *data;

@end

@implementation MutexDemo3

- (instancetype)init
{
    if (self = [super init]) {
        // 初始化属性
        pthread_mutexattr_t attr;
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
        // 初始化锁
        pthread_mutex_init(&_mutex, &attr);
        // 销毁属性
        pthread_mutexattr_destroy(&attr);
        
        // 初始化条件
        pthread_cond_init(&_cond, NULL);
        
        self.data = [NSMutableArray array];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}

// 生产者-消费者模式

// 线程1
// 删除数组中的元素
- (void)__remove
{
    pthread_mutex_lock(&_mutex);
    NSLog(@"__remove - begin");
    
    if (self.data.count == 0) {
        /*
         等待_mutex锁，同时进入休眠的状态；不会执行后面的代码，
         直到_cond的条件被唤醒之后，就会对_mutex进行加锁，并执行后面的代码。
         */
        pthread_cond_wait(&_cond, &_mutex);
    }
    
    [self.data removeLastObject];
    NSLog(@"删除了元素");
    //解锁
    pthread_mutex_unlock(&_mutex);
}

// 线程2
// 往数组中添加元素
- (void)__add
{
    //给_mutex加锁
    pthread_mutex_lock(&_mutex);
    //睡眠1秒
    sleep(1);
    
    [self.data addObject:@"Test"];
    NSLog(@"添加了元素");
    
    // 给_cond发送信号，唤醒pthread_cond_wait()这个等待的线程，并让他们执行后面的代码
    pthread_cond_signal(&_cond);
    //解锁
    pthread_mutex_unlock(&_mutex);
}

- (void)dealloc
{
    //销毁锁和销毁条件
    pthread_mutex_destroy(&_mutex);
    pthread_cond_destroy(&_cond);
}

@end

NSLock、NSRecursiveLock

  • NSLock是对mutex普通锁的封装。NSLock的API如下：
@protocol NSLocking

- (void)lock;
- (void)unlock;

@end

@interface NSLock : NSObject <NSLocking> {
@private
    void *_priv;
}

- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;

@property (nullable, copy) NSString *name API_AVAILABLE(macos(10.5), ios(2.0), watchos(2.0), tvos(9.0));

@end
  • NSRecursiveLock也是对mutex递归锁的封装，API跟NSLock基本一致。
@interface NSRecursiveLock : NSObject <NSLocking> {
@private
    void *_priv;
}

- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;

@property (nullable, copy) NSString *name API_AVAILABLE(macos(10.5), ios(2.0), watchos(2.0), tvos(9.0));

@end

以NSLock为例，demo如下：

@interface NSLockDemo()
@property (strong, nonatomic) NSLock *ticketLock;
@property (strong, nonatomic) NSLock *moneyLock;
@end

@implementation NSLockDemo


- (instancetype)init
{
    if (self = [super init]) {
        self.ticketLock = [[NSLock alloc] init];
        self.moneyLock = [[NSLock alloc] init];
    }
    return self;
}

// 死锁：永远拿不到锁
- (void)__saleTicket
{
    [self.ticketLock lock];
    
    [super __saleTicket];
    
    [self.ticketLock unlock];
}

- (void)__saveMoney
{
    [self.moneyLock lock];
    
    [super __saveMoney];
    
    [self.moneyLock unlock];
}

- (void)__drawMoney
{
    [self.moneyLock lock];
    
    [super __drawMoney];
    
    [self.moneyLock unlock];
}

@end

NSCondition

NSCondition是对mutex和cond的封装。NSCondition的API如下：

@interface NSCondition : NSObject <NSLocking> {
@private
    void *_priv;
}

- (void)wait;
- (BOOL)waitUntilDate:(NSDate *)limit;
- (void)signal;
- (void)broadcast;

@property (nullable, copy) NSString *name API_AVAILABLE(macos(10.5), ios(2.0), watchos(2.0), tvos(9.0));

@end

NSCondition的使用demo如下：

#import "NSConditionDemo.h"

@interface NSConditionDemo()
@property (strong, nonatomic) NSCondition *condition;
@property (strong, nonatomic) NSMutableArray *data;
@end

@implementation NSConditionDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.condition = [[NSCondition alloc] init];
        self.data = [NSMutableArray array];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}

// 生产者-消费者模式

// 线程1
// 删除数组中的元素
- (void)__remove
{
    [self.condition lock];
    NSLog(@"__remove - begin");
    
    if (self.data.count == 0) {
        // 等待
        [self.condition wait];
    }
    
    [self.data removeLastObject];
    NSLog(@"删除了元素");
    
    [self.condition unlock];
}

// 线程2
// 往数组中添加元素
- (void)__add
{
    [self.condition lock];
    
    sleep(1);
    
    [self.data addObject:@"Test"];
    NSLog(@"添加了元素");
    // 信号
    [self.condition signal];
    
    // 广播
//    [self.condition broadcast];
    [self.condition unlock];
    
}
@end

NSConditionLock

NSConditionLock是对NSCondition的进一步封装，可以设置具体的条件值；从而可以使线程按照一定的顺序执行；NSConditionLock的API如下：

@interface NSConditionLock : NSObject <NSLocking> {
@private
    void *_priv;
}

- (instancetype)initWithCondition:(NSInteger)condition NS_DESIGNATED_INITIALIZER;

@property (readonly) NSInteger condition;
- (void)lockWhenCondition:(NSInteger)condition;
- (BOOL)tryLock;
- (BOOL)tryLockWhenCondition:(NSInteger)condition;
- (void)unlockWithCondition:(NSInteger)condition;
- (BOOL)lockBeforeDate:(NSDate *)limit;
- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;

@property (nullable, copy) NSString *name API_AVAILABLE(macos(10.5), ios(2.0), watchos(2.0), tvos(9.0));

@end

demo如下：

@interface NSConditionLockDemo()
@property (strong, nonatomic) NSConditionLock *conditionLock;
@end

@implementation NSConditionLockDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__one) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__two) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__three) object:nil] start];
}

- (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];
}

- (void)__three
{
    [self.conditionLock lockWhenCondition:3];
    
    NSLog(@"__three");
    
    [self.conditionLock unlock];
}

@end

dispatch_semaphore

semaphore叫做”信号量”。信号量的初始值，可以用来控制线程并发访问的最大数量;
信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步。
信号量的使用：
在这里插入图片描述
信号量的demo：

@interface SemaphoreDemo()
@property (strong, nonatomic) dispatch_semaphore_t semaphore;
@property (strong, nonatomic) dispatch_semaphore_t ticketSemaphore;
@property (strong, nonatomic) dispatch_semaphore_t moneySemaphore;
@end

@implementation SemaphoreDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.semaphore = dispatch_semaphore_create(5);
        self.ticketSemaphore = dispatch_semaphore_create(1);
        self.moneySemaphore = dispatch_semaphore_create(1);
    }
    return self;
}

- (void)__drawMoney
{
    dispatch_semaphore_wait(self.moneySemaphore, DISPATCH_TIME_FOREVER);
    
    [super __drawMoney];
    
    dispatch_semaphore_signal(self.moneySemaphore);
}

- (void)__saveMoney
{
    dispatch_semaphore_wait(self.moneySemaphore, DISPATCH_TIME_FOREVER);
    
    [super __saveMoney];
    
    dispatch_semaphore_signal(self.moneySemaphore);
}

- (void)__saleTicket
{
    dispatch_semaphore_wait(self.ticketSemaphore, DISPATCH_TIME_FOREVER);
    
    [super __saleTicket];
    
    dispatch_semaphore_signal(self.ticketSemaphore);
}

- (void)otherTest
{
    for (int i = 0; i < 20; i++) {
        [[[NSThread alloc] initWithTarget:self selector:@selector(test) object:nil] start];
    }
}

// 线程10、7、6、9、8
- (void)test
{
    // 如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
    // 如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    
    sleep(2);
    NSLog(@"test - %@", [NSThread currentThread]);
    
    // 让信号量的值+1
    dispatch_semaphore_signal(self.semaphore);
}

@end

dispatch_queue

直接使用GCD的串行队列，也是可以实现线程同步的。使用方法如下：
在这里插入图片描述
demo如下：

@interface SerialQueueDemo()
@property (strong, nonatomic) dispatch_queue_t ticketQueue;
@property (strong, nonatomic) dispatch_queue_t moneyQueue;
@end

@implementation SerialQueueDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.ticketQueue = dispatch_queue_create("ticketQueue", DISPATCH_QUEUE_SERIAL);
        self.moneyQueue = dispatch_queue_create("moneyQueue", DISPATCH_QUEUE_SERIAL);
    }
    return self;
}

- (void)__drawMoney
{
    dispatch_sync(self.moneyQueue, ^{
        [super __drawMoney];
    });
}

- (void)__saveMoney
{
    dispatch_sync(self.moneyQueue, ^{
        [super __saveMoney];
    });
}

- (void)__saleTicket
{
    dispatch_sync(self.ticketQueue, ^{
        [super __saleTicket];
    });
}

@synchronized

@synchronized是对mutex递归锁的封装

源码查看：objc4中的objc-sync.mm文件

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

使用demo如下：

@implementation SynchronizedDemo

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

- (void)__saveMoney
{
    @synchronized([self class]) { // objc_sync_enter
        [super __saveMoney];
    } // objc_sync_exit
}

- (void)__saleTicket
{
    static NSObject *lock;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        lock = [[NSObject alloc] init];
    });
    
    @synchronized(lock) {
        [super __saleTicket];
    }
}

- (void)otherTest
{
    @synchronized([self class]) {
        NSLog(@"123");
        [self otherTest];
    }
}

各个锁性能的比较

在这里插入图片描述

自旋锁、互斥锁比较

  • 什么情况使用自旋锁比较划算？
- 预计线程等待锁的时间很短
- 加锁的代码（临界区）经常被调用，但竞争情况很少发生
- CPU资源不紧张
- 多核处理器
  • 什么情况使用互斥锁比较划算？
- 预计线程等待锁的时间较长
- 单核处理器
- 临界区有IO操作
- 临界区代码复杂或者循环量大
- 临界区竞争非常激烈
一人前行
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
iOS 线程同步几种方式
揽月御歌行
08-28 2934
多线程同步目的有以下几个方面：第一，对一段代码的执行进行保护，如果同时执行一段代码，中间的临时变量可能会互相干扰造成结果不对；第二，对资源的保护，多个线程执行不同的代码，但是可能涉及同一个资源；第三，消息传递，一个线程通知另外一个线程发生了一件事。 iOS中常用线程同步方式： NSLock 一个封装了pthread_mutex的OC对象，常用于保护一个代码块，如果NSLock对象已经被loc...
iOS 同步线程的方式
W10207010218的博客
03-24 560
同步线程说的是对多个并发线程同步 1 NSLock. NSCondition
iOS开发线程同步技术-锁
aifuyang1308的博客
01-03 85
概览 1，什么是锁（临界区）？ 2，常用的锁有哪些？ 3，相关链接 什么是锁（临界区） 临界区：指的是一块对公共资源进行访问的代码，并非一种机制或是算法。 常用的锁有哪些？ 互斥锁：是一种用于多线程编程中，防止两条线程同时对同一公共资源（比如全局变量）进行读写的机制。该目的通过将代码切片成一个一个的临界区而达成。 NSLock；pthread_mutex；@synchro...
iOS同步锁
路漫漫其修远兮，吾将上下而求索！
03-16 2165
iOS同步锁介绍，包含@synchronized、NSLock、dispatch_semaphore、NSCondition、pthread_mutex和OSSpinLock等。
正确理解iOS中的同步锁
最新发布
侯仕奇的博客
06-09 995
在 iOS 开发中，同步锁（synchronized lock）是一种用于管理多线程访问共享资源的机制，而不是某一种特定类型的锁。它涵盖了多种具体实现和技术，用于确保同一时间只有一个线程能够访问某个共享资源，从而避免数据竞争和确保数据一致性。这些同步机制的共同目标都是为了在多线程环境中保护共享资源，防止多个线程同时访问导致的竞态条件和数据不一致问题。具体使用哪种同步机制取决于具体的应用场景和需求。总结起来，同步锁是一种机制，其核心思想是通过某种锁的实现来管理多线程对共享资源的访问，确保线程安全。
iOS-线程同步的几种方式
SSY_1992的博客
03-16 2181
在多线程开发中数据的安全是非常重要的，在开辟分线程执行耗时操作以保证主线程不阻塞的同时，数据的安全也要保证才行。如果同一个资源（一个变量或者一段代码或者存储的数据等）同时被多个线程访问修改，可能会造成数据的错乱，得到的也就不是自己想要的结果，所以多线程开发中线程间的同步有时显得尤为重要。 实现多线程间的同步方式：锁（互斥锁、条件锁、递归锁）和GCD（队列、信号量、栅栏）。了解更多类型的锁可以查看线...
iOS 中常见的几种锁-代码示例
weixin_34366546的博客
07-16 216
iOS 中常见的几种锁介绍-示例 常用的各类锁性能比较 文中Demo 均实现在 XWInterviewDemos 1. iOS中的互斥锁 在编程中，引入对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问对象。 1.1 @synchronized (self) - (void)lock1 { @syn...
iOS中的多线程与线程同步
m0_60259116的博客
08-02 319
iOS中的多线程与线程同步
iOS线程同步方案
11-07
总之，iOS中的线程同步方案多种多样，开发者需要根据实际需求选择合适的工具来确保线程安全。理解并熟练掌握这些技术，对于编写高效、稳定的多线程代码至关重要。在实际应用中，合理地结合使用这些同步机制，能够...
详解iOS 多线程 锁 互斥 同步
08-31
以下是五种常见的iOS多线程同步方法的详解： 1. **@synchronized**：这是最简单的同步方式，通过给定的对象作为锁的关键字。`@synchronized(anObject)`会自动对`anObject`加锁，确保在`@synchronized`代码块内的...
详解iOS多线程之2.NSThread的加锁@synchronized
09-01
在日志输出中，我们可以看到三个线程交替执行售票操作，这证明了`synchronized`关键字成功地实现了线程同步。当票数变为0时，线程会打印“票卖完了”并调用`[NSThread exit]`退出线程，确保不会发生不必要的资源消耗...
IOS多线程编程系类
03-02
1.、NSThread2、CocoaNSOperation（IOS多线程编程之NSOperation和NSOperationQueue的使用）3、GCD全称：GrandCentralDispatch（IOS多线程编程之GrandCentralDispatch...线程同步对数据的加锁会有一定的系统开销NSThre
[iOS开发]iOS中的相关锁
weixin_52192405的博客
08-08 928
iOS相关锁学习
【iOS】【笔记】使用GCD实现同步锁
哔哔哔的专栏
04-17 700
这是阅读了 Effective Objective-C的第41条的总结 在iOS开发中会遇到多个线程要执行同一份代码的情况，比如同时修改统一个数据（火车卖票），通俗一点说就是抢占资源的问题。 通常要使用加锁来实现这种同步机制，在GCD出现之前，一共有两种方法。 1、同步块（synchroization block） -(void)sunchronizedMethod{ @...
iOS多线程编程：线程同步总结
热门推荐
lifengzhong的专栏
04-22 2万+
1：原子操作 - OSAtomic系列函数 iOS平台下的原子操作函数都以OSAtomic开头，使用时需要包含头文件。不同线程如果通过原子操作函数对同一变量进行操作，可以保证一个线程的操作不会影响到其他线程内对此变量的操作，因为这些操作都是原子式的。因为原子操作只能对内置类型进行操作，所以原子操作能够同步的线程只能位于同一个进程的地址空间内。 2：锁 - NSLock系列对象 iOS平台下的
采用信号量机制实现消费者与生产者的线程同步_知识篇，iOS线程同步!!!
weixin_39607798的博客
12-11 222
线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作。所以这里同步应该不是一起、共同完成的意思，可理解为协调就是按预定的先后次序进行工作，好比:'不要和我抢了，你先等会我做完了你在做'。线程同步目的为了多个线程都能很好的工作，合理的访问系统资源不争不抢、和谐共处。iOS开发中常用的保持线程同步有以下几种：通过线程...
iOS多线程安全-13种线程锁
bluemoon_0的博客
01-11 557
iOS多线程安全-13种线程锁🔒
iOS并发编程--8种加锁方式及比较
月若无涯的专栏
05-18 3640
iOS开发中不可避免的会遇到加锁的情况，今天就来比较一下各种加锁方式。目前我所知道的有如下几种加锁方式： 1. @synchronized 关键字加锁 2. NSLock 对象锁 3. NSCondition 4. NSConditionLock 条件锁 5. NSRecursiveLock 递归锁 6. pthread_mutex 互斥锁（C语言） 7. dispatch_sema
iOS之同步锁
孤城的博客
11-07 1229
iOS中的几种同步锁： 1、OSSpinLock 自旋锁，性能最高的锁。原理很简单，就是一直 do while 忙等。它的缺点是当等待时会消耗大量 CPU 资源，所以它不适用于较长时间的任务。对于内存缓存的存取来说，它非常合适。 2、dispatch_semaphore 是信号量，但当信号总量设为 1 时也可以当作锁来。在没有等待情况出现时，它的性能比 pthread_mutex 还要
iOS多线程编程实战指南
但同时，多线程也带来了同步问题、资源竞争等问题，需要开发者仔细设计和测试以确保程序的稳定性和性能。 iOS多线程编程是一个深度和广度并存的主题，涵盖了许多技术细节和最佳实践。掌握这些知识，开发者可以构建...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值