iOS 线程同步 自旋锁 OSSpinLock

#import "ViewController.h"
#import <libkern/OSAtomic.h>
@interface ViewController ()
@property (nonatomic,assign)  int ticket;
//@property (nonatomic,assign)  OSSpinLock lock;
@end

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
//    self.lock = OS_SPINLOCK_INIT;
    self.ticket=50;
    [self ticketsTest];
    // Do any additional setup after loading the view.
}
-(void)saleTicket{
    //静态创建、则不需要新建属性
    static OSSpinLock lock = OS_SPINLOCK_INIT;
    //若后面是个函数、则需
    /*
    static OSSpinLock lock = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        lock = OS_SPINLOCK_INIT;
    });
     */
    //其他线程执行到这里时,发现锁被加锁了 就会再这排队等待、直到这个锁被打开
    //加锁
    OSSpinLockLock(&lock);
    int ticket = self.ticket;
    sleep(.2);
    ticket--;
    self.ticket=ticket;
    NSLog(@"%d",self.ticket);
    //解锁
    OSSpinLockUnlock(&lock);
}
-(void)ticketsTest{
    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];
        }
    });
}

原文地址:https://www.cnblogs.com/ZhangShengjie/p/12275038.html

时间: 2024-08-29 22:22:47

iOS 线程同步 自旋锁 OSSpinLock的相关文章

iOS线程同步和锁

应用程序里面多个线程的存在引发了多个执行线程安全访问资源的潜在问题.两个线程同时修改同一资源有可能以意想不到的方式互相干扰. iOS 提供了你可以使用的多个同步工具,从提供互斥访问你程序的有序的事件的工具等.以下个部分介绍了这些工具和如何在代码中使用他们来影响安全的访问程序的资源. 我们通过同一个例子来说明这些锁,当两个线程同时操作一个可变数组时,一个线程添加数据,一个线程删除数据,类似一个生产消费者模式,就会存在线程安全问题: 使用POSIX互斥锁 __block pthread_mutex_

线程同步与锁

二元信号量,多元信号量,互斥量,临界区.其它包括读写锁,条件变量. -1:二元信号量,适合与只能被一个线程独占访问的资源.当二元信号量处于非占用状态时,第一个试图获取该二元信号量的线程会获得该锁,并将二元信号量重置为占用状态,在未释放该锁前,其它所有试图获取该二元信号量的线程将会等待. -2:多元信号量,简称信号量.一个初始值为N的信号量允许N个线程并发访问. 获取该信号量时,信号量的值减一,当信号量的值小于0时,再来获取信号量的线程进入等待状态. 释放该信号量时,信号量的值加一,当信号量的值大

python笔记10-多线程之线程同步(锁lock)

前言 关于吃火锅的场景,小伙伴并不陌生,吃火锅的时候a同学往锅里下鱼丸,b同学同时去吃掉鱼丸,有可能会导致吃到生的鱼丸.为了避免这种情况,在下鱼丸的过程中,先锁定操作,让吃火锅的小伙伴停一会,等鱼丸熟了再开吃,那么python如何模拟这种场景呢? 未锁定 1.如果多个线程同时操作某个数据,会出现不可预料的结果.比如以下场景:当小伙伴a在往火锅里面添加鱼丸的时候,小伙伴b在同时吃掉鱼丸,这很有可能导致刚下锅的鱼丸被夹出来了(没有熟),或者还没下锅,就去夹鱼丸(夹不到). # coding=utf-

偏向锁,偏向线程id ,自旋锁

理解锁的基础知识 如果想要透彻的理解Java锁的来龙去脉,需要先了解以下基础知识. 基础知识之一:锁的类型 锁从宏观上分类,分为悲观锁与乐观锁. 乐观锁 乐观锁是一种乐观思想,即认为读多写少,遇到并发写的可能性低,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,采取在写时先读出当前版本号,然后加锁操作(比较跟上一次的版本号,如果一样则更新),如果失败则要重复读-比较-写的操作. java中的乐观锁基本都是通过CAS操作实现的,CAS

Java线程 - CAS自旋锁(spin-lock)

一.自旋锁提出的背景 由于在多处理器系统环境中有些资源因为其有限性,有时需要互斥访问(mutual exclusion),这时会引入锁的机制,只有获取了锁的进程才能获取资源访问.即是每次只能有且只有一个进程能获取锁,才能进入自己的临界区,同一时间不能两个或两个以上进程进入临界区,当退出临界区时释放锁.设计互斥算法时总是会面临一种情况,即没有获得锁的进程怎么办?通常有2种处理方式.一种是没有获得锁的调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁,这就是自旋锁,他不用将县城阻塞起来(NON

Linux线程同步---互斥锁

线程中互斥锁使用的步骤与信号量相似! 1.首先定义互斥锁变量,并初始化 pthread_mutex_t mutex_lock;pthread_mutex_init(&mutex_lock,NULL);2.在操作前对互斥量进行加锁操作 pthread_mutex_lock(&mutex_lock);3.操作完毕后进行解锁操作 pthread_mutex_unlock(&mutex_lock); 所有操作均在加锁和解锁操作之间进行,保证同时仅仅对有一个操作对关键变量或是区域进行操作.

线程同步--悲观锁

在做数据库访问的时候,遇到了这样的问题:两个线程同时访问同一对象中的方法,那么就可能会引发数据不一致的问题,那么我们需要做的,就是加上锁. 第一种方案:Synchronized Java中用来给对象和方法或者代码加锁的,当他锁定一个方法或者一个代码块的时候,同一时刻最多只有一个线程执行该代码.当两个并发线程访问同一个对象object中的这个加锁同步代码块时,一个时间内只有一个线程得到,另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块. 用法:Synchronized 加入方法上和S

Linux 线程编程2.0——线程同步-互斥锁

当我们需要控制对共享资源的存取的时候,可以用一种简单的加锁的方法来控制.我们可以创建一个读/写程序,它们共用一个共享缓冲区,使用互斥锁来控制对缓冲区的存取. 函数 pthread_mutex_init()用来生成一个互斥锁.其函数原型如下: #include<pthread.h> int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr): 第一个参数是互斥变量

iOS 线程同步 NSLock、NSRecursiveLock、NSCondition

#import "ViewController.h" #import <pthread.h> @interface ViewController () @property (nonatomic, strong) NSCondition *lock; @property (nonatomic, strong) NSMutableArray *data; @end @implementation ViewController - (void)viewDidLoad { [sup