ios开发进阶之多线程01 线程 GCD

最新推荐文章于 2022-05-31 17:32:57 发布

贱兔不二

最新推荐文章于 2022-05-31 17:32:57 发布

阅读量559

点赞数

分类专栏： ios开发进阶之多线程与网络文章标签： ios ios开发多线程

本文链接：https://blog.csdn.net/ab20514/article/details/48025685

版权

ios开发进阶之多线程与网络专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一多线程基础

什么是进程？
- 进程是指在系统中正在运行的一个应用程序。
- 每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内。
什么是线程？
- 1个进程要想执行任务，必须得有线程（每1个进程至少要有1条线程）。
- 1个线程中任务的执行是串行的(执行完上一个才能执行下一个)。
什么是多线程？
- 1个进程中可以开启多条线程，多条线程可以并行（同时）执行不同的任务。
- 线程可以并行, 但是每个线程中的任务还是串行。
多线程原理
- 多线程并发（同时）执行，其实是CPU快速地在多条线程之间调度（切换）。
多线程优缺点
- 优点
  - 能适当提高程序的执行效率；
  - 能适当提高资源利用率（CPU、内存利用率）；
- 缺点
  - 线程越多，CPU在调度线程上的开销就越大；
  - 如果开启大量的线程，会降低程序的性能；
  - 程序设计更加复杂：比如线程之间的通信、多线程的数据共享。

二多线程在ios开发中的应用

什么是主线程？
- 一个iOS程序运行后，默认会开启1条线程，称为“主线程”或“UI线程”。
主线程的主要作用
- 显示\刷新UI界面；
- 处理UI事件（比如点击事件、滚动事件、拖拽事件等）；
主线程的使用注意
- 别将比较耗时的操作放到主线程中；
- 耗时操作会卡住主线程，严重影响UI的流畅度，给用户一种“卡”的坏体验；

1.如何获取主线程
    /*
    // 如果是主线程, 那么名称叫做main/ number = 1
    // 如果不是主线程, 那么名称就不叫做main / number != 1
    // 注意: currentThread代表拿到当前线程, 如果当前执行的方法是被主线程执行的, 那么拿到的就是主线程, 如果不是被主线程执行的, 那么拿到的就不是主线程
    NSLog(@"%@", [NSThread currentThread]);
    // 明确告诉系统, 需要拿到主线程
    NSLog(@"%@", [NSThread mainThread]);
     */ 

    // 2.如何判断当前方法是否实在主线程中执行的
    /*
    if ([NSThread isMainThread]) {
        NSLog(@"当前方法是在主线程中执行的");
    }

三 ios中多线程的实现方法

一. pthread

类型: C语言中类型的结尾通常 _t/Ref，而且不需要使用 *
创建C语言对象，一般都用creat

/*
 参数:
     1. 线程代号的地址
     2. 线程的属性
     3. 调用函数的指针
        - void *(*)(void *)
        - 返回值 (函数指针)(参数)
        - void * 和 OC 中的 id 是等价的
     4. 传递给该函数的参数
返回值:
     如果是0，表示正确
     如果是非0，表示错误码
*/
NSString *str = @"lnj";
    pthread_t thid;
    int res = pthread_create(&thid, NULL, &demo, (__bridge void *)(str));
    if (res == 0) {
        NSLog(@"OK");
    } else {
        NSLog(@"error %d", res);
    }

二. NSThread

一个NSThread对象就代表一条线程。
创建线程的几种方式
- alloc/init

    // 1.创建线程
    NJThread *thread = [[NJThread alloc] initWithTarget:self selector:@selector(demo:) object:@"lnj"];
    // 设置线程名称
    [thread setName:@"lmg"];
    // 设置线程的优先级，取值范围是0.0~1.0，默认是0.5
    // 优先级仅仅说明被CPU调用的可能性更大
    [thread setThreadPriority:1.0];
    // 2.启动线程
    [thread start];

detach/performSelector
- 优点：简单快捷
- 缺点：无法对线程进行更详细的设置

  1.创建线程（创建线程后自动启动线程）
[NSThread detachNewThreadSelector:@selector(demo:) toTarget:self withObject:@"lnj"];

// 1.创建线程（隐式创建并启动线程）
// 注意: Swift中不能使用, 苹果认为这个方法不安全
    [self performSelectorInBackground:@selector(demo:) withObject:@"lnj"];

三. GCD
四. NSOperation

四线程的状态

这里写图片描述

1.启动线程
- (void)start;
// 进入就绪状态 -> 运行状态。当线程任务执行完毕，自动进入死亡状态

2.阻塞（暂停）线程
+ (void)sleepUntilDate:(NSDate *)date;
+ (void)sleepForTimeInterval:(NSTimeInterval)time;
// 进入阻塞状态

[NSThread sleepForTimeInterval:2.0]; //线程睡2s
[NSThread sleepUntilDate:[NSDate distantFuture]]; //线程一直睡

3.强制停止线程
+ (void)exit;
// 进入死亡状态

[NSThread exit];

注意：一旦线程停止（死亡）了，就不能再次开启任务

五多线程的安全隐患

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

@synchronized(锁对象) { // 需要锁定的代码  }

// 售票方法
- (void)saleTicket
{
    while (1) {

        NSLog(@"欢迎光临");
        //  只要被synchronized{}扩住, 就能实现同一时刻, 只能有一个线程操作
        /*
        // 注意:
        // 1. 如果多条线程访问同一个资源, 那么必须使用同一把锁才能锁住
        // 2. 在开发中, 尽量不要加锁, 如果必须要加锁, 一定记住, 锁的范围不能太大, 哪里会有安全隐患就加在哪里
         */
        /*
        技巧: 开发中如果需要加锁, 一般都使用self
         */
        // 线程2: 等待,  线程3: 等待
        @synchronized(self){ // 锁住
            // 1.查询剩余的票数
            NSUInteger count = self.totalCount;
            // 2.判断是否还有余票
            if (count > 0) {
                // 线程1 100
                [NSThread sleepForTimeInterval:0.1];
                // 2.1卖票
                self.totalCount = count - 1; // 99
                NSLog(@"%@卖了一张票, 还剩%zd票", [NSThread currentThread].name, self.totalCount);
            }else
            {
                // 3.提示客户, 没有票了
                NSLog(@"对不起, 没有票了");
                break;
            }
        } // 解锁
    }
}

互斥锁的优缺点
优点：能有效防止因多线程抢夺资源造成的数据安全问题
缺点：需要消耗大量的CPU资源
互斥锁注意点
- 锁定1份代码只用1把锁，用多把锁是无效的
- 锁定范围越大, 性能越差
原子和非原子属性
- atomic：线程安全，需要消耗大量的资源
- nonatomic：非线程安全，适合内存小的移动设备
自旋锁 & 互斥锁

Synchronized: 互斥锁 —– Atomic: 自旋锁
- 共同点
  都能够保证同一时间，只有一条线程执行锁定范围的代码
- 不同点
  - 互斥锁：如果发现有其他线程正在执行锁定的代码，线程会进入”休眠”状态，等待其他线程执行完毕，打开锁之后，线程会被”唤醒”
  - 自旋锁：如果发现有其他线程正在执行锁定的代码，线程会”一直等待”锁定代码执行完成！
    自旋锁更适合执行非常短的代码，比较适合做一些不耗时的操作！

六线程间通信

什么叫做线程间通信
- 在1个进程中，线程往往不是孤立存在的，多个线程之间需要经常进行通信
线程间通信的体现
- 1个线程传递数据给另1个线程
- 在1个线程中执行完特定任务后，转到另1个线程继续执行任务
线程间通信常用方法：

- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait;

子线程做耗时操作, 主线程更新数据

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
 // 开启一个子线程下载图片
    [self performSelectorInBackground:@selector(downlod) withObject:nil];
}
- (void)downlod
{
    NSLog(@"%@", [NSThread currentThread]);
    // 1.下载图片
     NSURL *url = [NSURL URLWithString:@"http://pic.4j4j.cn/upload/pic/20130531/07ed5ea485.jpg"];
     NSData *data = [NSData dataWithContentsOfURL:url];
    // 2.将二进制转换为图片
    UIImage *image = [UIImage imageWithData:data];

    // 3.跟新UI
    /*
     waitUntilDone是否等待被调用方法执行完成，有可能也会等待调用方法的执行完成！
     YES: 等待被调用线程执行完毕再执行后面的代码
     NO : 不用等待被调用线程执行完毕就可以执行后面的代码
     */
     // 可以在指定的线程中, 调用指定对象的指定方法
[self performSelectorOnMainThread:@selector(showImage:) withObject:[UIImage imageWithData:data] waitUntilDone:YES];
}

七多线程GCD

什么是GCD
- 全称是Grand Central Dispatch，可译为“牛逼的中枢调度器”
GCD的优势
- GCD是苹果公司为多核的并行运算提出的解决方案
- GCD会自动利用更多的CPU内核（比如双核、四核）
- GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
- 程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码
GCD中有2个核心概念
- 任务：执行什么操作
- 队列：用来存放任务
GCD的使用就2个步骤：
1、定制任务
* 确定想做的事情
2、将任务添加到队列中
* GCD会自动将队列中的任务取出，放到对应的线程中执行
* 任务的取出遵循队列的FIFO原则：先进先出，后进后出
执行任务
GCD中有2个用来执行任务的常用函数：

//用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
queue：队列
block：任务
//用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

- 同步和异步的区别
     * 同步：只能在当前线程中执行任务，不具备开启新线程的能力
     * 异步：可以在新的线程中执行任务，具备开启新线程的能力

队列的类型
- 并发队列
  - 可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
  - 并发功能只有在异步（dispatch_async）函数下才有效
- 串行队列
  - 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
注意点
- 同步和异步主要影响：能不能开启新的线程
  - 同步：只是在当前线程中执行任务，不具备开启新线程的能力
  - 异步：可以在新的线程中执行任务，具备开启新线程的能力
- 并发和串行主要影响：任务的执行方式
  - 并发：允许多个任务并发（同时）执行
  - 串行：一个任务执行完毕后，再执行下一个任务
并发队列
1.使用dispatch_queue_create函数创建队列

dispatch_queue_t
dispatch_queue_create(const char *label, // 队列名称 
dispatch_queue_attr_t attr); // 队列的类型
// 创建并发队列
dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", DISPATCH_QUEUE_CONCURRENT);

2.系统提供的全局的并发队列

// 使用dispatch_get_global_queue函数获得全局的并发队列
dispatch_queue_t dispatch_get_global_queue(
dispatch_queue_priority_t priority, // 队列的优先级
unsigned long flags); // 此参数暂时无用，用0即可

// 获得全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

串行队列
- GCD中获得串行有2种途径
  1.使用dispatch_queue_create函数创建串行队列

// 创建串行队列（队列类型传递NULL或者DISPATCH_QUEUE_SERIAL）
dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", NULL);

2.使用主队列（跟主线程相关联的队列）
主队列是GCD自带的一种特殊的串行队列
放在主队列中的任务，都会放到主线程中执行

使用dispatch_get_main_queue()获得主队列
dispatch_queue_t queue = dispatch_get_main_queue();

各种任务队列搭配
- 异步 + 并发 : 会开启新的线程

 /*
     第一个参数: 队列的名称
     第二个参数: 告诉系统需要创建一个并发队列还是串行队列
     DISPATCH_QUEUE_SERIAL :串行
     DISPATCH_QUEUE_CONCURRENT　并发
     */
    dispatch_queue_t queue = dispatch_queue_create("com.520it", DISPATCH_QUEUE_CONCURRENT);

 dispatch_async(queue, ^{
        NSLog(@"任务1  == %@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务2  == %@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务3  == %@", [NSThread currentThread]);
    });

系统内部提供一个现成的并发队列

/*
     第一个参数: iOS8以前是优先级, iOS8以后是服务质量
     iOS8以前
     *  - DISPATCH_QUEUE_PRIORITY_HIGH          高优先级 2
     *  - DISPATCH_QUEUE_PRIORITY_DEFAULT:      默认的优先级 0
     *  - DISPATCH_QUEUE_PRIORITY_LOW:          低优先级 -2
     *  - DISPATCH_QUEUE_PRIORITY_BACKGROUND:

     iOS8以后
     *  - QOS_CLASS_USER_INTERACTIVE  0x21 用户交互(用户迫切想执行任务)
     *  - QOS_CLASS_USER_INITIATED    0x19 用户需要
     *  - QOS_CLASS_DEFAULT           0x15 默认
     *  - QOS_CLASS_UTILITY           0x11 工具(低优先级, 苹果推荐将耗时操作放到这种类型的队列中)
     *  - QOS_CLASS_BACKGROUND        0x09 后台
     *  - QOS_CLASS_UNSPECIFIED       0x00 没有设置

     第二个参数: 废物
     */

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

异步 + 串行：会开启新的线程，但是只会开启一个新的线程

// 1.创建串行队列
    dispatch_queue_t queue = dispatch_queue_create("com.520it", DISPATCH_QUEUE_SERIAL);
    /*
     能够创建新线程的原因:使用"异步"函数调用
     只创建1个子线程的原因:队列是串行队列
     */
    // 2.将任务添加到队列中
    dispatch_async(queue, ^{
        NSLog(@"任务1  == %@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务2  == %@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务3  == %@", [NSThread currentThread]);
    })；

同步 + 串行：如果是调用同步函数, 那么会等同步函数中的任务执行完毕, 才会执行后面的代码

dispatch_queue_t queue = dispatch_queue_create("com.520it", NULL);

    // 2.将任务添加到队列中
    dispatch_sync(queue, ^{
        NSLog(@"任务1  == %@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"任务2  == %@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"任务3  == %@", [NSThread currentThread]);
    });

同步 + 并发 : 不会开启新的线程

// 1.创建一个并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

    // 2.将任务添加到队列中
    dispatch_sync(queue, ^{
        NSLog(@"任务1  == %@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"任务2  == %@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"任务3  == %@", [NSThread currentThread]);
    });

异步 + 主队列 : 不会创建新的线程, 并且任务是在主线程中执行

// 主队列特点: 只要将任务添加到主队列中, 那么任务"一定"会在主线程中执行 \
    无论你是调用同步函数还是异步函数:

    dispatch_queue_t queue = dispatch_get_main_queue();

    dispatch_async(queue, ^{
        NSLog(@"%@", [NSThread currentThread]);
    });

同步函数 + 主队列
- 如果是在主线程中调用同步函数 + 主队列, 那么会导致死锁
  导致死锁的原因:
  如果是调用同步函数, 那么会等同步函数中的任务执行完毕, 才会执行后面的代码；
  sync函数是在主线程中执行的, 并且会等待block执行完毕. 先调用
  block是添加到主队列的, 也需要在主线程中执行. 后调用
- 在子线程中调用同步函数 + 主队列


    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_async(queue, ^{
        // block会在子线程中执行
        //        NSLog(@"%@", [NSThread currentThread]);

        dispatch_queue_t queue = dispatch_get_main_queue();
        dispatch_sync(queue, ^{
            // block一定会在主线程执行
            NSLog(@"%@", [NSThread currentThread]);
        });
    });

八 GCD线程间通信

// 1.除主队列以外, 随便搞一个队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

    // 2.调用异步函数
    dispatch_async(queue, ^{
        // 1.下载图片
        NSURL *url = [NSURL URLWithString:@"http://pic.4j4j.cn/upload/pic/20130531/07ed5ea485.jpg"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        // 2.将二进制转换为图片
        UIImage *image = [UIImage imageWithData:data];

        // 3.回到主线程更新UI
//        self.imageView.image = image;
        /*
         技巧:
         如果想等UI更新完毕再执行后面的代码, 那么使用同步函数
         如果不想等UI更新完毕就需要执行后面的代码, 那么使用异步函数
         */
        dispatch_sync(dispatch_get_main_queue(), ^{
            self.imageView.image = image;
        });
        NSLog(@"设置图片完毕 %@", image);
    });

九 GCD其它常用方法

延时执行
方法一：调用NSObject的方法

[self performSelector:@selector(run) withObject:nil afterDelay:2.0];
// 2秒后再调用self的run方法

方法二：使用GCD函数

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 2秒后执行这里的代码...
});

一次性代码
使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    // 只执行1次的代码(这里面默认是线程安全的)
});

快速迭代
使用dispatch_apply函数能进行快速迭代遍历

dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index){
    // 执行10次代码，index顺序不确定
});

应用场景–拷贝文件：

// 1.定义变量记录原始文件夹和目标文件夹的路径
    NSString *sourcePath = @"/Users/xiaomage/Desktop/test";
    NSString *destPath = @"/Users/xiaomage/Desktop/lnj";
    // 2.取出原始文件夹中所有的文件
    NSFileManager *manager = [NSFileManager defaultManager];
    NSArray *files = [manager subpathsAtPath:sourcePath];
    //    NSLog(@"%@", files);
    // 3.开始拷贝文件
    dispatch_apply(files.count, dispatch_get_global_queue(0, 0), ^(size_t index) {
        NSString *fileName = files[index];
        // 3.1生产原始文件的绝对路径
        NSString *sourceFilePath = [sourcePath stringByAppendingPathComponent:fileName];
        // 3.2生产目标文件的绝对路径
        NSString *destFilePath = [destPath stringByAppendingPathComponent:fileName];
        //        NSLog(@"%@", sourceFilePath);
        //        NSLog(@"%@", destFilePath);
        // 3.3利用NSFileManager拷贝文件
        [manager moveItemAtPath:sourceFilePath toPath:destFilePath error:nil];
    });

控制任务之间的关系
- 有这么1种需求
  - 首先：分别异步执行2个耗时的操作
  - 其次：等2个异步操作都执行完毕后，再回到主线程执行操作

如果想要快速高效地实现上述需求，可以考虑用队列组

dispatch_group_t group =  dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行1个耗时的异步操作
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行1个耗时的异步操作
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    // 等前面的异步操作都执行完毕后，回到主线程...
});

贱兔不二

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ios开发进阶之多线程01 线程 GCD

一多线程基础什么是进程？进程是指在系统中正在运行的一个应用程序。每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内。什么是线程？1个进程要想执行任务，必须得有线程（每1个进程至少要有1条线程）。1个线程中任务的执行是串行的(执行完上一个才能执行下一个)。什么是多线程？1个进程中可以开启多条线程，多条线程可以并行（同时）执行不同的任务。线程可以并行, 但是每个线程中的任务还
复制链接

扫一扫