多线程以及底层实现

一.概念

  • 什么是进程

    • 进程是指在系统中正在运行的一个应用程序
    • 每个进程之间的是独立的,每个进程均运行在其专用且受保护的内存空间内
    • 一个进程至少要有一个线程
  • 什么是线程
    • 一个线程要执行任务,必须得有线程
    • 一个进程(程序)的所有任务都在线程中执行的
    • 一个线程执行任务是串行的,也就是说一个线程,同一时间内,只能执行一个任务
  • 多线程原理
    • 同一时间,CPU只能处理1条线程,只有一条线程在工作(执行)
    • 多线程并发(同时)执行,其实质是CPU快速的在多线程之间调度(切换)
  • 如果线程过多,会怎样?
    • CPU在N多条线程中调度,会消耗大量的cpu资源
    • 每条线程被调度执行的频率越低(线程的执行效率低)
  • 多线程的优点
    • 能适当提高程序的执行效率
    • 能适当提高资源的利用率(CPU 内存利用率等)
  • 多线程的缺点
    • 创建线程是有开销的，iOS下主要成本包括：内核数据结构（大约1KB）、栈空间（子线程512KB、主线程1MB，也可以使用-setStackSize:设置，但必须是4K的倍数，而且最小是16K），创建线程大约需要90毫秒的创建时间
    • 如果开启大量的线程,会降低程序的性能
    • 程序越多CPU的线程上的开销就越大
    • 程序设计更加复杂:线程之间的通讯,多线程的数据共享
  • 什么是主线程
    • 一个ios程序运行后,会开启一条线程,称为主线程,或者是UI线程
  • 主线程的主要作用
    • 显示和刷新UI界面
    • 处理UI事件(比如点击事件,滚动事件,拖拽事件等)
  • 主线程的使用注意
    • 别将比较耗时的操作放在主线程中,会导致UI界面的卡顿
    • 将耗时操作放在子线程(后台线程,非主线程)

二.多线程的4种方案

  • 1.C语言的POSIX接口:#include

+ (NSThread *)mainThread; // 获得主线程
- (BOOL)isMainThread; // 是否为主线程
+ (BOOL)isMainThread; // 是否为主线程```
- 其他用法
  ```objc//创建NSThread对象
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:nil object:nil];
    //获取当前线程
    NSThread *thread1 = [NSThread currentThread];
    //设置线程的名字
    thread.name = @"这是设置线程名字的";
    [thread setName:@"这也是设置线程的名字的"];```
- 线程状态
![这里写图片描述](http://img.blog.csdn.net/20160615133614638)
- 互斥锁
 - @synchronized(锁对象) { // 需要锁定的代码  }
注意：锁定1份代码只用1把锁(同个对象)，用多把锁是无效的
 - 优点:能有效防止因多线程抢夺资源造成的额数据安全问题
 - 缺点:需要消耗大量的CPU资源
 - 使用前提:多线程同一时间抢夺同一块资源
 - 互斥锁就是使用了线程同步技术.就是多线程在按顺序执行
- OC在定义属性时有nonatomic和atomic两种选择
atomic：原子属性，为setter方法加锁（默认就是atomic）
nonatomic：非原子属性，不会为setter方法加锁

###1.常用的方法
```objc
//在主线程中执行任务
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(nullable id)arg waitUntilDone:(BOOL)wait modes:(nullable NSArray<NSString *> *)array;
//YES表示等Selector执行完后才执行后面
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(nullable id)arg waitUntilDone:(BOOL)wait;
//开辟一条子线程执行任务
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(nullable id)arg waitUntilDone:(BOOL)wait modes:(nullable NSArray<NSString *> *)array
//开辟一条子线程执行任务
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(nullable id)arg waitUntilDone:(BOOL)wait
//在后台执行任务(相当于开辟了一个子线程)
- (void)performSelectorInBackground:(SEL)aSelector withObject:(nullable id)arg
//类方法,开辟一条子线程执行任务
[NSThread detachNewThreadSelector:@selector(test:) toTarget:self withObject:@"hello"];

<div class="se-preview-section-delimiter"></div>

//开启子线程,并且要通过手动开启线程,否则无法执行任务的

// 创建线程
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(download:) object:@"Alloc"];
    // 开启线程,将线程添加到线程可调度池里,等待CPU的调度
    [thread start];

<div class="se-preview-section-delimiter"></div>

//线程睡眠

//睡眠1秒
[NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:1.0]];
//线程睡眠1秒
[NSThread sleepForTimeInterval:1.0];

<div class="se-preview-section-delimiter"></div>

//线程退出,千万不要在主线程退出,否则程序就会出现各种问题,包括奔溃,黑屏,不能响应

[NSThread exit];

<div class="se-preview-section-delimiter"></div>

2.线程的取消

 // 创建线程--> 新建状态
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(download) object:nil];
    // 开启线程--> 将线程添加到可调度线程池中,等待CPU调度
    [thread start];
    // 睡
    [NSThread sleepForTimeInterval:0.2];
    // 取消线程执行,取消线程仅仅是给线程打上一个被取消的标记
    // 要实现真正取消线程的执行需要在线程内部的关键节点进行判断
    [thread cancel];
    NSLog(@"over");

<div class="se-preview-section-delimiter"></div>

3.线程的优先级

    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(test:) object:@"---"];
    thread.name = @"线程A";
    //设置线程的优先级,范围是0到1
    thread.threadPriority = 1.0;
    [thread start];

<div class="se-preview-section-delimiter"></div>

4.线程栈区的大小

// 不管主线程还是子线程,栈区大小默认都是512kb.
    //    NSLog(@"stackSize = %zd",[NSThread currentThread].stackSize / 1024);
    // 最小的栈区大小是16kb,必须是4的整数倍,建议不要修改栈区大小,使用默认即可.
    [NSThread currentThread].stackSize = 1024 * 1024;
    NSLog(
    @"stackSize = %zd",[NSThread currentThread].stackSize / 1024)

<div class="se-preview-section-delimiter"></div>

5.多线程访问数据导致的数据异常的处理

多个线程访问数据的时候会导致数据异常,这时候我们要使用互斥锁

// 先保证单条线程能正确工作:能够买完所有票
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    self.ticket = 20;
    // 创建线程
    NSThread *threadA = [[NSThread alloc] initWithTarget:self selector:@selector(saleTicket) object:nil];
    threadA.name = @"美女A";
    // 开启线程
    [threadA start];

    // 创建线程
    NSThread *threadB = [[NSThread alloc] initWithTarget:self selector:@selector(saleTicket) object:nil];
    threadB.name = @"美女B";
    // 开启线程
    [threadB start];
}
- (void)saleTicket {
    while (YES)
    {
            // 睡
            [NSThread sleepForTimeInterval:1.0];
            // 使用互斥锁:可以保证锁住的代码同一时间只有一个线程访问.
            // 使用互斥锁锁住的代码要尽可能少,锁住关键节点的代码即可.
            // [[NSUserDefaults standardUserDefaults] synchronize];
            //@synchronized

           // self:锁对象,可以是任意NSObject类的对象.
           // 注意点:锁对象必须是所有线程对象能同时访问的对象.
           // 如果只有一个地方使用到互斥锁,一般锁对象就是self`,避免再创建一个对象.
           // NSObject *lockObj = [[NSObject alloc] init];
        @synchronized(self)
        {
            // 判断是否有剩余的票数
            if(self.ticket > 0)
            {
                // 如果有,则卖一张
                self.ticket --;
                NSLog(@"%@卖了一张票,剩余的票数:%zd",[NSThread currentThread].name, self.ticket);
                continue;
            }
        }
        // 没有票,则提示用户票没了
        NSLog(@"票没了");
        break;
    }
    NSLog(@"over");
}

<div class="se-preview-section-delimiter"></div>

拓展:

?nonatomic 与 atomic
1)iOS中还有一种锁 原子锁atomic
2)nonatomic 非原子属性 (线程不安全),
3)atomic 原子属性,默认都是"原子"属性 (线程安全),也不能保证数据写入的正确性 4)原子属性,也是一个多线程技术,setter/getter函数是一个原子操作,如果多线程同时调用setter
时,不会出现某一个线程执行完setter所有语句之前,另一个线程就开始执行setter,相当于函数头尾 加了锁. 这样的话并发访问性能会比较低.
提示:设置原子属性后,不要自己去写原子属性的setter方法
原因:原子属性默认的setter方法中,使用了“128位自旋锁”,性能比互斥锁高,但是同样消耗性 能

<div class="se-preview-section-delimiter"></div>
  • ##3.C语言的GCD(性能好,代码更精简)

    • 什么是GCD
    • 全称是 Grand Central Dispatch，可译为“牛逼的中枢调度器”
    • 纯C语言,提供了非常多强大的函数
    • GCD的优势
    • GCD是苹果公司为多核的并行运算提出的解决方案
    • GCD会自动利用更多的CPU内核（比如双核、四核）
    • GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
    • 程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码
    • GCD的有四种队列:串行队列,并行队列,全局队列,主队列.
    • GCD有两种操作:异步操作,同步操作.
    • 异步操作dispatch_async,”会并发执行”,无法确定任务的执行顺序
    • 同步操作dispatch_sync,”会依次顺序执行”,能够决定任务的执行顺序
    • 主队列可以看成串行队列,如果在主线程中使用同步操作,那就会造成线程阻塞
    • 一个线程只能属于一个进程,而一个进程可以有多个线程,但至少有一个线程,线程是操作

      系统可识别的最小执行和调度单位.

1.CGD的常用使用

注意:在主线程中,执行同步操作,里面的任务将不会执行(阻塞),同步异步决定是否可以开子线程,队列决定任务是怎么执行的.

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
//    [self gcdDemo1];//cgd的同步和异步执行任务.
//    [self gcdDemo2];
//    [self gcdDemo3];
}
//cgd的同步和异步执行任务.
-(void)gcdDemo1
{
    void (^gcdBlock)() = ^()
    {
        NSLog(@"这是简单的block,%@",[NSThread currentThread]);
    };
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_sync(queue, gcdBlock);//开启子线程
    dispatch_async(queue, gcdBlock);//不开启子线程
}
//gcd的常用写法(精简版)
- (void)gcdDemo2
{
    //在全局队列异步执行
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"async---%@",[NSThread currentThread]);
    });
    //在主队列中异步执行.(没有开启子线程)
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"async---%@",[NSThread currentThread]);
    });
    //在主队列同步执行
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"sync---%@",[NSThread currentThread]);
    });
}
//线程间的通讯
- (void)gcdDemo3
{
    //在异步开启子线程
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"这是耗时任务---%@",[NSThread currentThread]);
        //异步在主线程执行任务
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"回到主线程刷新UI--%@",[NSThread currentThread]);
        });
    });
}

<div class="se-preview-section-delimiter"></div>

2.CGD中的串行队列

/// 串行队列异步执行
/// 提问:会不会开线程? 是否是顺序执行?
/// 问答:会开线程  开多条 是
- (void)gcdDemo3{
    for (int i = 0; i < 10; i++) {
        // 参数1:队列的名称
        dispatch_queue_t queue = dispatch_queue_create("itcast", DISPATCH_QUEUE_SERIAL);
        // 将任务添加到队列中,并指定执行任务的函数
        dispatch_async(queue, ^ {
            NSLog(@"%@--%d",[NSThread currentThread],i);
        });
    }
}
/// 串行队列同步执行
/// 提问:会不会开线程? 是否是顺序执行?
/// 问答:不会开线程  是
- (void)gcdDemo1 {
    // 创建串行队列
    // 参数1:队列的名称
    dispatch_queue_t queue = dispatch_queue_create("itcast", DISPATCH_QUEUE_SERIAL);
    for (int i = 0; i < 10; ++i) {
        // 将任务添加到队列中,并指定执行任务的函数
        dispatch_sync(queue, ^ {
            NSLog(@"%@--%d",[NSThread currentThread],i);
        });
    }
}
/// 串行队列异步执行
/// 提问:会不会开线程? 开几条线程? 是否是顺序执行?
/// 问答:会开线程  开1条   是  全对
- (void)gcdDemo2 {
    // 创建串行队列
    // 参数1:队列的名称
    dispatch_queue_t queue = dispatch_queue_create("itcast", DISPATCH_QUEUE_SERIAL);
    for (int i = 0; i < 10; ++i) {
        // 将任务添加到队列中,并指定执行任务的函数
        dispatch_async(queue, ^ {
            NSLog(@"%@--%d",[NSThread currentThread],i);
        });
    }
}

<div class="se-preview-section-delimiter"></div>

3.GCD中的并发队列

/// 并发队列同步执行
/// 提问:会不会开线程? 开几条? 是否是顺序执行?
/// 答案:不会开  顺序
- (void)gcdDemo1 {
    // 创建串行队列
    // 参数1:队列的名称
    for (int i = 0; i < 10; ++i) {
        // 将任务添加到队列中,并指定执行任务的函数
        dispatch_queue_t queue = dispatch_queue_create("itcast", DISPATCH_QUEUE_CONCURRENT);
        dispatch_sync(queue, ^ {
            NSLog(@"%@--%d",[NSThread currentThread],i);
        });
    }
}
/// 串行队列异步执行
/// 提问:会不会开线程? 开几条线程? 是否是顺序执行?
/// 问答:会开线程  不知道,由底层线程池决定   不是
- (void)gcdDemo2 {
    // 创建串行队列
    // 参数1:队列的名称
    dispatch_queue_t queue = dispatch_queue_create("itcast", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0; i < 5; ++i) {
        // 将任务添加到队列中,并指定执行任务的函数
        dispatch_async(queue, ^ {
            NSLog(@"%@--%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"下载xxxx=%@",[NSThread currentThread]);
    NSLog(@"下载B=%@",[NSThread currentThread]);
    dispatch_async(queue, ^{
        NSLog(@"下载C=%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"下载A=%@",[NSThread currentThread]);
    });
}

<div class="se-preview-section-delimiter"></div>

4.GCD中的主队列(特殊的串行队列)

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    NSLog(@"start");
    [self gcdDemo3];
    NSLog(@"end");
}

///主队列同步执行不死锁
- (void)gcdDemo3 {
    // 获得主队列
    dispatch_queue_t queue =  dispatch_get_main_queue();
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"over = %@",[NSThread currentThread]);
        // 同步任务
        dispatch_sync(queue, ^{
            NSLog(@"%@---%zd",[NSThread currentThread],100);
        });
    });
}

///主队列同步执行
- (void)gcdDemo2 {
    // 获得主队列
    dispatch_queue_t queue =  dispatch_get_main_queue();
    // 同步任务
    // 主队列中的任务必须在主线程空闲的时才会执行.
    // 主队列中添加同步任务会造成死锁.
    dispatch_sync(queue, ^{
        NSLog(@"%@---%zd",[NSThread currentThread],100);
    });
    NSLog(@"over");
}
//主队列异步执行
- (void)gcdDemo1 {
    // 获得主队列
    dispatch_queue_t queue =  dispatch_get_main_queue();
    for (int i = 0; i < 5; ++i) {
        // 异步任务
        dispatch_async(queue, ^{
            NSLog(@"%@---%zd",[NSThread currentThread],i);
        });
    }
}

<div class="se-preview-section-delimiter"></div>

5.GCD中的全局队列

//全局队列异步执行
//全局队列特点跟并发队列是一样的
// dispatch_get_global_queue:获得全局队列不需要关心什么时候销毁
// 自己创建的并发队列需要在不使用的时候销毁
// 一般开发第三方框架时会是用自定义并发队列.
- (void)gcdDemo1 {
    // 获得主队列
//    Flags that are reserved for future use. Always specify 0 for this parameter
    // 参数1:
    // 参数2:保留给未来使用,永远给个0
    dispatch_queue_t queue =  dispatch_get_global_queue(0, 0);
    for (int i = 0; i < 10; ++i) {
        // 异步任务
        dispatch_async(queue, ^{
            NSLog(@"%@---%zd",[NSThread currentThread],i);
        });
    }
    // 在ARC中不允许调用release方法
//    dispatch_release(queue);
}

<div class="se-preview-section-delimiter"></div>

6.CGD中的dispatch_barrier_async,barrier异步的使用

使用 dispatch_barrier_async 添加的 block 会在之前添加的 block 全部运行结束之后，统一在同一个线程顺序执行，从而保证对非线程安全的对象进行正确的操作！

- (void)viewDidLoad {
    [super viewDidLoad];
    // 创建并发队列
    queue  = dispatch_queue_create("itcast", DISPATCH_QUEUE_CONCURRENT);
    // dispatch_barrier_async:一定是要使用自定义并发队列
//     queue  = dispatch_get_global_queue(0, 0);
    for (int i = 0; i < 20; ++i) {
        [self loadImage:i];
    }
}
/// 加载index索引指定图片
// 主要用于在多个异步操作完成之后，统一对非线程安全的对象进行更新
- (void)loadImage:(NSInteger)index{
    dispatch_async(queue, ^{
        // 获得图片名称
        NSString *imageName = [NSString stringWithFormat:@"%zd.jpg",index % 9];
        // 获得图片路径
        NSString *filePath = [[NSBundle mainBundle] pathForResource:imageName ofType:nil];
        // 加载图片
        UIImage *image = [UIImage imageWithContentsOfFile:filePath];
        NSLog(@"下载第%zd张图片,%@",index,[NSThread currentThread]);
        dispatch_barrier_async(queue, ^{
            NSLog(@"第%ld张图片下载完成=%@,",(long)index,[NSThread currentThread]);
            // 将图片添加到数组中
            // NSMutableArray不是线程安全的类
            // NSMutableDictionary也不是线程安全的类的
            // 凡是带有mutable单词的类都不是线程安全.
            [self.images addObject:image];
        });
    });
}

<div class="se-preview-section-delimiter"></div>

7.dispatch_after操作和dispatch_once

1.dispatch_after

    dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4.0 * NSEC_PER_SEC));
    //延时操作,这里是开启了子线程的
    dispatch_after(when, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"延迟操作是子线程:%@",[NSThread currentThread]);
        NSLog(@"这是延迟操作!!!");
    });   

<div class="se-preview-section-delimiter"></div>

2.dispatch_once

//使用dispatch_once实现单例,以及和互斥锁实现单例的比较

(dispatch_once实现的单例比互斥锁实现的单例效率高)

// dispatch_once {}
// 1.要提供一个全局的访问点
// 2.在这个项目中,只会有一个实例对象
+(instancetype)sharedHttpTool {
    static id instance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 在这里写的代码在整个项目运行过程中只会执行一次
        NSLog(@"是一次吗");
        instance = [[self alloc] init];
    });
    return instance;
}

// 使用互斥锁实现单例
+ (instancetype)sharedSync {
    static id instance = nil;
    @synchronized(self) {
        if (instance == nil) {
            instance = [[self alloc] init];
        }
    }
    return instance;
}

<div class="se-preview-section-delimiter"></div>

8.调度组

- (void)gcdDemo1 {
    // 组对象
    dispatch_group_t group = dispatch_group_create();
    // 队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_group_async(group, queue, ^{
        [NSThread sleepForTimeInterval:0.5];
        NSLog(@"下载图片1=%@",[NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        [NSThread sleepForTimeInterval:1.5];
        NSLog(@"下载图片2=%@",[NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        [NSThread sleepForTimeInterval:2.5];
        NSLog(@"下载图片3=%@",[NSThread currentThread]);
    });
    // dispatch_group_notify:当组里面的所有任务执行完毕,会在主队列中添加任务.并执行任务
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
         NSLog(@"更新UI %@",[NSThread currentThread]);
    });

    NSLog(@"come here");

//    dispatch_group_async(group, dispatch_get_main_queue(), ^{
//        NSLog(@"更新UI %@",[NSThread currentThread]);;
//    });
}

<div class="se-preview-section-delimiter"></div>

9.dispatch_apple的使用

NSArray *arr = @[@1,@2,@3,@4,@5];
    CFTimeInterval begin1 = CFAbsoluteTimeGetCurrent();
    dispatch_apply(arr.count, dispatch_get_global_queue(0, 0), ^(size_t index)
    {
        NSLog(@"%@,%@",arr[index],[NSThread currentThread]);

    });
    CFTimeInterval begin2 = CFAbsoluteTimeGetCurrent();
    NSLog(@"%lf",begin1 - begin2);

<div class="se-preview-section-delimiter"></div>
  • 4.Objective-C的NSOperation和NSOperationQueue(基于GCD)

    ###示例代码:

    1.用start添加任务和开启线程

//添加任务和线程的开启
- (void)opDemo1
{
    NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(test) object:nil];
    //用start开启开启线程是在当前线程中执行任务的
    [op start];
}
- (void)test
{
    NSLog(@"it is test method-->%@",[NSThread currentThread]);
}

<div class="se-preview-section-delimiter"></div>

2.operation添加操作和开启线程

- (void)opDemo2
{
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    //设置队列的并发数
    //如果设置为1,那么就变成了串行队列
    queue.maxConcurrentOperationCount = 2;
    for (int i = 0; i < 10; i ++) {
        //添加操作
        NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(test:) object:nil];
        //往队列中添加操作就-->开启了异步(除了在mainQueue中不开启子线程)
         [queue addOperation:op];
    }
        NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"这是block操作-->%@",[NSThread currentThread] );
    }];
    [[[NSOperationQueue alloc] init] addOperation:op];
}

<div class="se-preview-section-delimiter"></div>

 NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        // 在主线程
        NSLog(@"下载1------%@", [NSThread currentThread]);
    }];

    // 添加额外的任务(在子线程执行)
    [op addExecutionBlock:^{
        NSLog(@"下载2------%@", [NSThread currentThread]);
    }];

    [op addExecutionBlock:^{
        NSLog(@"下载3------%@", [NSThread currentThread]);
    }];
    [op addExecutionBlock:^{
        NSLog(@"下载4------%@", [NSThread currentThread]);
    }];

    [op start];

3.线程间通信

//线程间的通讯
- (void)opDemo3
{
    [[[NSOperationQueue alloc] init] addOperationWithBlock:^{
        [NSThread sleepForTimeInterval:2.0];
        NSLog(@"这是耗时操作--%@",[NSThread currentThread]);
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            NSLog(@"UI更新--%@",[NSThread currentThread]);
        }];
    }];
}

4.队列的挂起,开启以及取消队列操作

//控制队列的挂起和开启的按钮点击事件
- (IBAction)pauseAndResume {
    if(self.queue.operationCount == 0) {
        NSLog(@"队列中没有操作");
        return;
    }
    // 设置队列的挂起状态
    // setter  = !getter
    self.queue.suspended = !self.queue.isSuspended;
    // 挂起队列不会影响正在执行的操作
    // operationCount中包含没有执行完毕的所有操作.
    // 队列如果是挂起的,再往队列中添加操作,也不会执行
    if (self.queue.suspended) {
        NSLog(@"暂停 = %zd",self.queue.operationCount);
    } else {
        NSLog(@"继续 = %zd",self.queue.operationCount);
    }
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    for (int i = 0; i < 20; ++i)
    {
        NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
            [NSThread sleepForTimeInterval:1.0];
            NSLog(@"%@--%d", [NSThread currentThread],i);
        }];
        [self.queue addOperation:op];
    }
}
- (NSOperationQueue *)queue {
    if (_queue == nil) {
        _queue = [[NSOperationQueue alloc] init];
        // 设置最大并发数
        _queue.maxConcurrentOperationCount = 2;
    }
    return _queue;
}

5.任务之间添加依赖

- (void)op1
{
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    NSBlockOperation *bop = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"111bop,%@",[NSThread currentThread]);
    }];
    //往bop任务中添加额外的任务
    [bop addExecutionBlock:^{
        NSLog(@"2222---%@",[NSThread currentThread]);
    }];
    NSInvocationOperation *iop = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(top) object:nil];
    NSInvocationOperation *iop2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(top2) object:nil];
    //必须先添加依赖,再把任务添加到队列中
    [bop addDependency:iop];
    [iop addDependency:iop2];
    [queue addOperation:bop];
    //添加任务到队列中
    [queue addOperation:iop];
    [queue addOperation:iop2];
}
时间： 2024-11-02 21:52:45

多线程以及底层实现的相关文章

java多线程synchronized底层实现

一直想把这个特别重要的关键词的底层实现搞明白.(当然现在也没有完全明白,如果有错误以后修改这篇文章) 首先,这个关键词synchronize可以说是个语法糖,它的具体用法网上很多博客都讲的比较明了了. 简而言之就是对一个对象“加锁”.首先,找个地方的对象不一定是堆里面的类的实例对象,也有可能是方法区的类对象.其次,这个关键词修饰的代码块的加锁过程有两个,进入的时候尝试获得锁(java字节码 monitorenter),退出时释放锁(java字节码monitorexit).这两个操作的再下一层是基

Python多线程（1）——介绍

Python对多线程提供了很好的支持,Python中多线程相关的模块包括:thread,threading,Queue.可以方便地支持创建线程.互斥锁.信号量.同步等特性. 1. thread:多线程的底层支持模块,除了其中提供的 Lock 原语外,一般不建议使用. 2. threading:基于 thread 模块,将一些线程的操作对象化,该模块提供下列类: Thread,线程类 Timer,与Thread类似,但要等待一段时间后才开始运行 Lock,锁原语,和 thread 模块提供的 Lo

iOS中面试题之----多线程

1.多线程的底层实现 (1)首先回答什么是线程 1个进程要想执行任务,必须得有线程.线程是进程的基本执行单元,一个进程(程序)的所有任务都在线程中执行 (2)什么是多线程 1个进程中可以开启多条线程,每条线程可以并行(同时)执行不同的任务. 多线程的作用:更新显示UI界面.处理用户触摸事件. (3)Mach是第一个以多线程方式处理任务的系统,因此多线程的底层实现机制是基于Mach的线程. (4)开发中实现多线程的方案 1>C语言的POSIX接口:#include<pthread.h> 2

python之多线程并发处理模块-threading

thread:多线程的底层支持模块,一般不建议使用: threading:对thread进行了封装,将一些线程的操作对象化,一般采用这种方法实现多线程编程 多线程实现有两种模式: 1.创建线程要执行的函数,把这个函数传递进Thread对象里 2.直接从Threading继承,新建一个新的类class, threading模块: threading.Thread类的重要函数 threading.currentThread(): 返回当前的线程变量. threading.enumerate(): 返

NDK使用技巧、多线程调用注意、ndk中的工具使用

//NDK 使用技巧和多线程调用注意 //http://www.ibm.com/search/csass/search/?q=ndk&sn=dw&lang=zh&cc=CN&en=utf&hpp=20&dws=cndw&lo=zh void demo(JNIEnv* env, jobject thiz) { //这JNI接口指针可以存储,但只在当前线程仍然是有效的. /* A JNI environment pointer (JNIEnv*) is

【学习总结】【多线程】一些面试题

1. 多线程的底层实现?多线程的实现原理?多线程有什么作用?使用场合是什么? 一般问这个的话,比较空泛,分析一下,问题如没实际使用场景的话,可从问题原理上解释 1.1) 首先搞清楚什么是线程.什么是多线程.还可以适当带一下进程的概念. Mach系统是第一个以多线程方式处理的任务~.(了解) [学习总结][多线程] 线程 & 进程 & NSThread(多线程的一套API)

多线程网络

1.多线程的底层实现 1> 首先搞清楚什么是线程.什么是多线程 2> Mach是第一个以多线程方式处理任务的系统,因此多线程的底层实现机制是基于Mach的线程 3> 开发中很少用Mach级的线程,因为Mach级的线程没有提供多线程的基本特征,线程之间是独立的 4> 开发中实现多线程的方案 C语言的POSIX接口:#include <pthread.h> OC的NSThread C语言的GCD接口(性能最好,代码更精简) OC的NSOperation和NSOperatio

Python：使用threading模块实现多线程（转）

分类: python   标签: thread    评论: 暂无评论   阅读:5,420 views 综述 Python这门解释性语言也有专门的线程模型,Python虚拟机使用GIL(Global Interpreter Lock,全局解释器锁)来互斥线程对共享资源的访问,但暂时无法利用多处理器的优势. 在Python中我们主要是通过thread和 threading这两个模块来实现的,其中Python的threading模块是对thread做了一些包装的,可以更加方便的被使用,所以我们使用

python多线程编程（1）

虚拟机层面 Python虚拟机使用GIL(Global Interpreter Lock,全局解释器锁)来互斥线程对共享资源的访问,暂时无法利用多处理器的优势. 语言层面 在语言层面,Python对多线程提供了很好的支持,Python中多线程相关的模块包括:thread,threading,Queue.可以方便地支持创建线程.互斥锁.信号量.同步等特性. thread:多线程的底层支持模块,一般不建议使用. threading:对thread进行了封装,将一些线程的操作对象化,提供下列类: Th