iOS多线程学习

最新推荐文章于 2023-03-27 19:07:03 发布
最新推荐文章于 2023-03-27 19:07:03 发布
阅读量211 收藏
点赞数
分类专栏： iOS 文章标签： ios api 多线程 gcd
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32031183/article/details/71088792
版权

1. GCD的API

/**
 serial(连续的)
 dispatch(分派)
 serialDispatch 一个线程,同时执行的处理只能有一个,按顺序执行
 */
void test_serialDispatch(){
    dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("com.example.gcd.MySerialDispatchQueue", NULL);

    void(^blk_0)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_1)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_2)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_3)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_4)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_5)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_6)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_7)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    dispatch_async(mySerialDispatchQueue, blk_0);
    dispatch_async(mySerialDispatchQueue, blk_1);
    dispatch_async(mySerialDispatchQueue, blk_2);
    dispatch_async(mySerialDispatchQueue, blk_3);
    dispatch_async(mySerialDispatchQueue, blk_4);
    dispatch_async(mySerialDispatchQueue, blk_5);
    dispatch_async(mySerialDispatchQueue, blk_6);
    dispatch_async(mySerialDispatchQueue, blk_7);
    //    dispatch_release(mySerialDispatchQueue);
    NSLog(@"%s,%d",__func__,__LINE__);
}

/**
 concurrent(并发的,同时发生的)
 concurrentDispatch 多个线程,并行执行
 */
void test_concurrentDispatch(){
    dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("com.example.gcd.MyConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);
    void(^blk_0)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_1)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_2)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_3)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_4)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_5)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_6)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    void(^blk_7)(void) = ^() {
        NSLog(@"%s,%d",__func__,__LINE__);
    };
    dispatch_async(myConcurrentDispatchQueue, blk_0);
    dispatch_async(myConcurrentDispatchQueue, blk_1);
    dispatch_async(myConcurrentDispatchQueue, blk_2);
    dispatch_async(myConcurrentDispatchQueue, blk_3);
    dispatch_async(myConcurrentDispatchQueue, blk_4);
    dispatch_async(myConcurrentDispatchQueue, blk_5);
    dispatch_async(myConcurrentDispatchQueue, blk_6);
    dispatch_async(myConcurrentDispatchQueue, blk_7);
    //    dispatch_release(myConcurrentDispatchQueue);
    NSLog(@"%s,%d",__func__,__LINE__);
}
void test_Main_Global_DispatchQueue(){

    /**主线程*/
    dispatch_queue_t mainDispachQueue = dispatch_get_main_queue();
    /**高优先级*/
    dispatch_queue_t globalDispatchQueueHigh = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
    /**默认优先级*/
    dispatch_queue_t globalDisaptchQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    /**低优先级*/
    dispatch_queue_t globalDispatchQueueLow = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
    /**后台优先级*/
    dispatch_queue_t globalDispatchQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
}
/**改变线程的优先级*/
void test_dispatch_set_target_queue(){
    //要变更优先级的dispatch queue
    dispatch_queue_t myserialDispatchQueue = dispatch_queue_create("com.example.gcd.MySerialDispatchQueue", NULL);
    //目标
    dispatch_queue_t globalDispatchQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
    dispatch_set_target_queue(myserialDispatchQueue, globalDispatchQueueBackground);
}
void test_dispatch_after(){
    /*注意:
     dispatch_after函数并不是在指定时间后执行处理,
     而是在指定时间追加处理到Dispatch Queue
     NSEC_PER_SEC 秒
     NSEC_PER_MSEC 毫秒
     NSEC_PER_USEC 微妙
     */
    dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3ull * NSEC_PER_USEC);
    dispatch_after(time, dispatch_get_main_queue(), ^{
        NSLog(@"%s %d",__func__,__LINE__);
    });
    NSDate *date = [[NSDate alloc]initWithTimeIntervalSinceNow:5];
    dispatch_after(getDispatchTimeByDate(date), dispatch_get_main_queue(), ^{
        NSLog(@"%s %d",__func__,__LINE__);
    });
    NSLog(@"%s %d",__func__,__LINE__);
}
//返回指定日期时间
dispatch_time_t getDispatchTimeByDate(NSDate *date){
    NSTimeInterval interval;
    double second, subsecond;
    struct timespec time;
    dispatch_time_t milestone;

    interval = [date timeIntervalSince1970];
    /*
     modf() 将浮点数分解为整数和小数部分，其原型为：
     double modf (double x, double* intpart);
     */
    subsecond = modf(interval, &second);

    time.tv_sec = second;
    time.tv_nsec = subsecond * NSEC_PER_SEC;

    milestone = dispatch_walltime(&time, 0);

    return milestone;
}

/**
 无论向什么样的Dispatch Queue中追加处理,使用Dispatch Group都可监视这些处理执行的结束.一旦测试到所有处理执行结束,就可将结束的处理追加到Dispatch Queue中
 */
void test_Dispatch_Group(){
    dispatch_queue_t queue = dispatch_queue_create(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();
    dispatch_async(queue, ^{
        NSLog(@"%s %d",__func__,__LINE__);
    });
    dispatch_async(queue, ^{
        NSLog(@"%s %d",__func__,__LINE__);
    });
    dispatch_async(queue, ^{
        NSLog(@"%s %d",__func__,__LINE__);
    });
//    notify(通知)
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"done");
    });

}
void test_Dispatch_group_wait(){
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();

    dispatch_group_async(group, queue, ^{
        NSLog(@"%s %d",__func__,__LINE__);
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"%s %d",__func__,__LINE__);
    });
    dispatch_group_async(group, queue, ^{
        sleep(4);
        NSLog(@"%s %d",__func__,__LINE__);
    });
    //在Dispatch Group中也可以使用dispatch_group_wait函数仅等待全部处理执行结束
//    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

    long result = dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, 3ULL * NSEC_PER_SEC));
    if (result == 0) {
        NSLog(@"属于Dispatch Group的全部处理执行结束");
    }else{
        NSLog(@"属于Dispatch Group的某一个处理还在执行中");
    }
}

/**
 barrier(障碍)
 应用于处理数据的读写问题

 写入处理不可以与其他的写入处理以及包含读取处理的其
 他某些处理并行执行.
 但是,读取处理只是与读取处理并行执行,那么多个并行执
 行就不会发生问题.
 就是说:在写入处理结束之前,读取处理不可执行
 */
void test_dispatch_barrier_async(){
    dispatch_queue_t queue = dispatch_queue_create("com.example.gcd.ForBarrier", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"reading data %d",__LINE__);
    });
    dispatch_async(queue, ^{
        NSLog(@"reading data %d",__LINE__);
    });
    dispatch_async(queue, ^{
        NSLog(@"reading data %d",__LINE__);
    });
    dispatch_async(queue, ^{
        NSLog(@"reading data %d",__LINE__);
    });
    dispatch_barrier_async(queue, ^{
        NSLog(@"begin writing data %d",__LINE__);
        sleep(4);
        NSLog(@"end writing data %d",__LINE__);

    });
//    dispatch_async(queue, ^{
//        NSLog(@"begin writing data %d",__LINE__);
//        sleep(4);
//        NSLog(@"end writing data %d",__LINE__);
//    });
    dispatch_async(queue, ^{
        NSLog(@"reading data %d",__LINE__);
    });
    dispatch_async(queue, ^{
        NSLog(@"reading data %d",__LINE__);
    });
}

/**
 asynchronous(异步的)
 synchronous(同步的)
 */
void test_dispatch_sync(){
//    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//    dispatch_sync(queue, ^{
//        NSLog(@"同步处理");
//    });

    //死锁
//    dispatch_queue_t queue = dispatch_get_main_queue();
//    dispatch_sync(queue, ^{
//        NSLog(@"Hell world");
//    });
//    dispatch_async(queue, ^{
//        dispatch_sync(queue, ^{
//             NSLog(@"Hell world");
//        });
//    });
    dispatch_queue_t queue = dispatch_queue_create("com.example.gcd.MySerialDispatchQueue", NULL);
    dispatch_async(queue, ^{
        dispatch_sync(queue, ^{
            NSLog(@"Hell world");
        });
    });
}
void test_Dispatch_Apply(){
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//    dispatch_apply(10, queue, ^(size_t index) {
//        NSLog(@"%zu",index);
//    });
    NSArray *array = @[@10, @9, @7, @6, @5, @4, @3, @2, @1];
    dispatch_async(queue, ^{
        dispatch_apply([array count], queue, ^(size_t index) {
            NSLog(@"%zu %@",index, [array objectAtIndex:index]);
        });
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"done");
        });
    });
}

/**
 dispatch_supsend(queue)挂起
 dispatch_resume(queue)回复
 */
void test_dispatch_supsend_dispatch_resume(){
    dispatch_queue_t queue = dispatch_queue_create("com.test.gcd", DISPATCH_QUEUE_SERIAL);
    //提交第一个block，延时5秒打印。
    dispatch_async(queue, ^{
        sleep(5);
        NSLog(@"After 5 seconds...");
    });
    //提交第二个block，也是延时5秒打印
    dispatch_async(queue, ^{
        sleep(5);
        NSLog(@"After 5 seconds again...");
    });
    //延时一秒
    NSLog(@"sleep 1 second...");
    sleep(1);
    //挂起队列
    NSLog(@"suspend...");
    dispatch_suspend(queue);
    //延时10秒
    NSLog(@"sleep 10 second...");
    sleep(10);
    //恢复队列
    NSLog(@"resume...");
//    dispatch_resume(queue);
}

/**
 semaphore(信号)
 */
void test_dispatch_semaphore(){
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    /**
     生成dispatch_semaphore.并将计数初始值设定为1
     保持可访问NSMutableArray类对象的线程同时只能有一个
     */
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

    NSMutableArray *array = [NSMutableArray array];

    for (int i = 0; i < 10000; i++) {
        //一直等待,直到Dispatch Semaphore 的计数值达到大于等于1
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        [array addObject:[NSNumber numberWithInt:i]];
        /*

         */
        dispatch_semaphore_signal(semaphore);
    }
}

/**
 保证函数在应用程序中只执行一次处理
 生成单例对象使用
 */
void test_dispatch_once(){
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"初始化单例");
    });
}
void test_dispatch_io(){
}
void test_timer(){
    NSLog(@"%s",__func__);
    /*指定DISPATCH_SOURCE_TYPE_TIMER, 作成Dispatch Source*/
    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
    /*
     将定时器设定为15秒后
     不指定为重复
     允许延迟1秒
     */
    dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, 15ULL * NSEC_PER_SEC), DISPATCH_TIME_FOREVER, 1ULL * NSEC_PER_SEC);
    //指定定时器时间内执行处理
    dispatch_source_set_event_handler(timer, ^{
        NSLog(@"wakeup");
        //取消Dispatch Source
        dispatch_source_cancel(timer);
    });
    //指定取消Dispatch Source时处理
    dispatch_source_set_cancel_handler(timer, ^{
        NSLog(@"cancel");
    });
    //启动Dispatch Source
    dispatch_resume(timer);
}
 1. (void)countDownWithTime:(int)time
           countDownBlock:(void (^)(int timeLeft))countDownBlock
                 endBlock:(void (^)())endBlock
{
    __block int timeout = time; //倒计时时间
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_source_t _timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0,queue);
    dispatch_source_set_timer(_timer,dispatch_walltime(NULL, 0),1.0*NSEC_PER_SEC, 0); //每秒执行
    dispatch_source_set_event_handler(_timer, ^{
        if(timeout<=0){ //倒计时结束，关闭
            dispatch_source_cancel(_timer);
            dispatch_async(dispatch_get_main_queue(), ^{
                if (endBlock) {
                    endBlock();
                }
            });
        } else {
            dispatch_async(dispatch_get_main_queue(), ^{
                timeout--;
                if (countDownBlock) {
                    countDownBlock(timeout);
                }
            });
        }
    });
    dispatch_resume(_timer);
}

2. NSThread

#pragma mark:NSThread
 1. (void)testThread{
    NSString *url = @"http://img4.imgtn.bdimg.com/it/u=2437762035,2994278153&fm=23&gp=0.jpg";
//    [NSThread detachNewThreadSelector:@selector(downLoadData:) toTarget:self withObject:url];
    NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(downLoadData:) object:url];
    [thread start];
}
 2. (void)downLoadData:(NSString *)url{
    NSLog(@"begin download.....");
    for (int i = 0 ; i < 5; i++) {
        sleep(1);
        NSLog(@"download....%d%%",(i+1) * 20);
    }
    NSLog(@"finish download......");
    [self performSelectorOnMainThread:@selector(refreshUI:) withObject:[NSData data] waitUntilDone:YES];
}
 3. (void)refreshUI:(NSData *)data{
    NSLog(@"%s",__func__);
}
 4. (void)test_tickets{
    tickets = 100;
    count = 0;
    theLock = [[NSLock alloc] init];
    // 锁对象
    ticketsCondition = [[NSCondition alloc] init];
    ticketsThreadone = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
    [ticketsThreadone setName:@"Thread-1"];
    [ticketsThreadone start];

    ticketsThreadtwo = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
    [ticketsThreadtwo setName:@"Thread-2"];
    [ticketsThreadtwo start];
}
 5. (void)run{
    while (TRUE) {
        // 上锁
        //        [ticketsCondition lock];
        [theLock lock];
        if(tickets >= 0){
            [NSThread sleepForTimeInterval:0.09];
            count = 100 - tickets;
            NSLog(@"当前票数是:%d,售出:%d,线程名:%@",tickets,count,[[NSThread currentThread] name]);
            tickets--;
        }else{
            break;
        }
        [theLock unlock];
        //        [ticketsCondition unlock];
    }   
}

3. NSOperation

/**
 使用 NSOperation的方式有两种，
 一种是用定义好的两个子类：NSInvocationOperation 和 NSBlockOperation。
 另一种是继承NSOperation
 */
-(void)testNSOperation{
    NSString *url = @"http://img4.imgtn.bdimg.com/it/u=2437762035,2994278153&fm=23&gp=0.jpg";
    NSInvocationOperation *operation = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(downLoadData:) object:url];
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    [queue addOperation:operation];
}

相关链接:http://blog.jobbole.com/69019/

沉淀繁华
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
iOS多线程变成指南
11-06
### iOS多线程编程指南知识点概述 #### 一、多线程编程概念及重要性 - **多线程定义**：多线程是指在单一应用程序内同时运行多个代码执行路径的技术。 - **目的**：提高应用程序响应速度和效率，通过并行处理任务...
iOS 多线程总结
04-01
本文将深入探讨四种主要的iOS多线程机制：Pthreads、NSThread、GCD（Grand Central Dispatch）以及NSOperation和NSOperationQueue。 首先，Pthreads是POSIX线程库的一部分，支持跨平台的多线程编程。在iOS中，虽然...
iOS 多线程学习
pelsor的专栏
05-07 406
占个坑，有时间学习。
IOS多线程学习一：多线程及其相关概念
煮酒Shae
02-11 172
多线程及其相关概念一：进程二：线程线程的串行三.多线程1.多线程的原理2.多线程的优缺点3.多线程在iOS中的应用主线程主线程的作用主线程的使用注意iOS中多线程的使用方案 一：进程 进程：是指在系统中正在运行的一个应用程序。 eg:比如同时打开微信，QQ,系统就会分别启动两个进程。 每个进程之间是独立的且均运行在其专用并受保护的内存空间内。 二：线程 线程是进程的基本执行单元，一个进程要想执行任...
iOS多线程——GCD学习总结
最新发布
cyberjack的博客
03-27 1327
iOS GCD详解
ios多线程学习之GCD线程锁
学习路上
11-30 1709
因为在以前的开发中实在是很少会用到多线程的知识，但是现在手中的项目是做视频开发。 而在视频开发类项目中，最困难的就是逻辑和多线程处理，这几天没事研究了一下线程锁，我觉的一个简答的代码实例，就能体现出 GCD 线程锁的特征 还是先了解一点，在GCD 中实现锁的操作是通过线程队列来实现的 首先是一段没有锁操作的简单线程处理         dispatch_async(
iOS多线程学习笔记
Jolie_Yang的博客
11-11 865
iOS多线程 NSThread NSOperation GCD 锁机制 NSLock同步锁 synchronized代码块 GCD中dispatch_semaphore_t信号量 小结 并发编程 概述 基础定义 基础算法TODO 并发防御原则 小结 参考资料7th,Dec,2015iOS多线程 “iOS中多线程使用并不复杂，关键是如何控制好各个线程的执行顺序、处理好资源竞争问题。”–KenShi
iOS 多线程 再学习
baidu_40537062的博客
02-17 495
几乎是默写出来，加上自己理解的博客（iOS面试）
iOS开发之多线程
逝水无情的博客
08-31 3108
iOS开发之多线程本文章博主和大家一块学习多线程，很自然就涉及到线程和进程，然后涵括NSThread、GCD、NSOperation！然后就是最牛叉的RunLoop和Runtime。一、线程与进程进程是指在系统中正在运行的一个应用程序，就是一段程序的执行过程，每个进程之间是相互独立的。一个进程要想执行任务，必须要有线程，至少有一条线程，一个进程的所有任务都是在线程中执行。其实应用程序启动的时候我么你
iOS多线程概念总结
Mr_yu__的博客
08-07 1146
自定义KVO的实现 1setter
iOS多线程图解
no_chinese_name的博客
03-25 223
看到好友关于多线程的图解的博客：http://www.henishuo.com/ios-multithread-detail/。纲举目张，条理清晰，对于大家掌握多线程大有裨益，推荐给大家。具体学习还需要大家自己平时深入钻研、总结、实践： 关注微博私信：http://weibo.com/490jiulin/home?wvr=5 ...
iOS多线程Demo
05-30
总之，“iOS多线程Demo”是一个很好的学习资源，它涵盖了iOS多线程开发的基础和实践，包括NSOperationQueue、GCD和NSThread的使用，以及多线程下的UI更新和线程安全。通过这个Demo，开发者可以更深入地理解多线程...
ios 多线程
08-16
在iOS开发中，多线程是一项至关重要的技术，它使得应用程序能够同时执行多...《多线程编程指南》和《内存管理编程指南》这两本电子书，将为开发者提供深入的理论知识和实践指导，是学习和提升iOS多线程技术的宝贵资源。
从OC到swift的一些总结
沉淀繁华的博客
08-14 4171
最近工作不是很忙，我花了两个星期的时间学习了一些swift。虽然swift出来快两年了，但是我一直没有去学习。近来听好多朋友说，他们已经开始用swift开发了，我决定学习一下swift基础的东西，在这里列出我一些学习总结。我不善于写文章，我就大片的粘上代码好了，有OC基础的人，基本上一看就懂了。swift几个诡异符号的意义苹果总是能弄出一些与众不同的代码书写方式，比如oc中的字符串写法。果然swif
xcode 插件的安装使用与管理
沉淀繁华的博客
04-03 367
xcode的插件的使用可以调高工作效率,方便编写代码.废话不说,先说说怎么安装xcode插件. 我以Alcatraz这个插件为例来说一下怎么安装xcode插件.为啥用这个插件为例呢?因为这个插件使用来管理xcode上的插件的,有了Alcatraz你可以轻松的安装与删除插件. 第一步:下载Alcatraz  , 地址:https://github.com/mneorr/Alcatraz; 第二
iOS CocoaPods安装和使用
沉淀繁华的博客
04-16 316
sudo gem update --system 升级Ruby环境 gem sources --remove https://rubygems.org/gem sources -a https://ruby.taobao.org/ 用淘宝来镜像gem sources -l 验证淘宝镜像*** CURRENT SOURCES *** https://ruby.taobao.org/che
iOS 消息机制与运行时 运用runtime字典转模型
沉淀繁华的博客
10-24 313
文章中的Demo地址https://github.com/InnerMongoliaZorro/runtime 开始学习iOS开发的时候,对Objective-C的消息转发机制和运行时十分不解,感觉很高深的样子,就一直没有下功夫去研究这些问题.最近看了一些资料,对这部分知识做了一些总结,分享出来供大家参考学习,若有错误请联系我更正,大家共同进步. 1.动态绑定与静态绑定 绑定是一个把过程调用和
iOS多线程编程指南
“IOS 多线程文档” 本文档是关于iOS平台上多线程编程的详细指南，由Apple Inc.原著，谢业兰（老狼）翻译，并...这份文档为开发者提供了全面的指导，包括实例代码和实践建议，是学习和优化iOS多线程应用的宝贵资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值