拼音_
拼音_

iOS多线程

iOS多线程

多线程基础

在学习多线程之前, 按照惯例, 先普及一些概念, 为接下来的学习做铺垫.

进程

进程是指在系统中正在运行的一个应用程序, 在一个系统中, 进程之间是相互独立的. 每个进程运行在其专用且收保护的内存空间内

线程

进程想要执行任务, 必须在线程下执行, 每1个进程至少要有一条线程, 我们称之为主线程.

线程与进程的关系

一个进程中至少包含一个线程, 同一个进程内的线程共享进程的资源.

主线程

一个iOS程序运行时, 默认会开启1条线程, 称为主线程或UI线程.
主线程的作用: 刷新UI 显示UI界面, 处理UI事件, 比如点击, 滑动

使用主线程注意:
不要把耗时操作放到主线程中, 会影响UI的流畅度

多线程

一个进程中可以开启多条线程, 多条线程可以同时执行不同的任务, 多线程技术可以提高程序的执行效率.

多线程原理

对于单核CPU, 同一时间, CPU只能处理1条线程, 多线程并发执行, 其实是CPU快速的在多条线程之间来回切换, 如果CPU调度线程到的速度足够快, 就造成了多线程并发的假象.

多线程的优点

  • 能适当提高程序的执行效率
  • 能适当提高资源利用率(CPU, 内存利用率)

多线程的缺点

  • 创建线程是需要成本的, iOS下主要包括, 在栈空间的子线程512KB, 主线程1MB, 创建线程大约需要90毫秒的创建时间.
  • 线程越多, CPU在调度线程上的开销就越大
  • 线程越多, 程序设计就越复杂, 因为要考虑到线程之间的通信, 多线程的数据共享

多线程实现方案

在iOS开发中, 有多重多线程方案可以供我们选择, 一般用其中三种

NSThread

  • 使用面向对象
  • 简单易用, 可以直接操作线程对象
  • 使用Objective-C, 由程序员管理线程生命周期

GCD

  • 旨在替代NSThread等多线程技术
  • 充分利用设备的多核
  • 使用C语言, 自动管理线程生命周期

NSOperation

  • 基于GCD, 更加面向对象
  • 使用Objective-C, 自动管理线程的生命周期

NSThread

NSThread是基于线程使用, 较轻量级的多线程编程方法(相对于GCD和NSOperation), 一个NSThread对象代表一个线程, 需要手动管理线程的生命周期, 处理线程同步等问题.

NSThread的创建

动态创建, 动态方法返回一个新的thread对象, 需要调用start方法来启动线程

NSTHread *newThread = [[NSThread alloc] initWithTarget:self selector:@selector(threadRun) object:nil];

静态创建, 静态方法没有返回值, 如果需要获取新创建的thread, 需要在Selector中调用获取当前线程的方法

[NSThread detachNewThreadSelector:@selector(threadRun) toTarget:self withObject:nil];

设置线程的名字

[newThread setName:@"线程名字"];
newThread.name = @"线程名字";

线程开启

[newThread start];

线程暂停

NSThread的暂停会有阻塞当前线程的效果

// 暂停1秒
[NSThread sleepForTimeInterval:1.0];
[NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:1.0]];

线程取消

取消线程并不会马上停止并退出线程, 仅仅只作(线程是否需要退出)状态记录

[newThread cancel];

线程停止

停止方法会立即终止除主线程以外的所有线程(无论是否在执行任务)并退出, 需要在掌控所有线程状态的情况下调用此方法, 否则可能会导致内存问题

[NSThread exit];

获取当前线程

[NSThread currentThread];

获取主线程

[NSThread mainThread];

线程优先级设置

iOS8以前用

// 设置线程优先级, 默认0.5 取值范围0.0-1.0
[NSThread setThreadPriority:1.0];

iOS8以后推荐使用 枚举值

[newThread setQualityOfService:NSQualityOfServiceUserInitiated];

NSQualityOfServiceUserInteractive  // 最高优先级, 用于用户交互事件
NSQualityOfServiceUserInitiated    // 次高优先级, 用于用户需要马上执行的事件
NSQualityOfServiceDefault          // 默认优先级, 主线程和没有设置优先级的线程都默认为这个优先级
NSQualityOfServiceUtility          // 普通优先级, 用于普通任务
NSQualityOfServiceBackground       // 最低优先级, 用于不重要的任务
  • 获取指定线程的优先级
[newThread threadPriority];

线程间的通信

常见的有三种:

指定当前线程执行操作

[self performSelector:@selector(threadRun)];
[self performSelector:@selector(threadRun) withObject:nil];
[self performSelector:@selector(threadRun) withObject:nil afterDelay:2.0];

(在其他线程中)指定主线程执行操作

[self performSelectorOnMainThread:@selector(threadRun) withObject:nil waitUntilDone:YES];

(在主线程中)指定其他线程执行操作

// 这里为指定某个线程
[self performSelector:@selector(threadRun) onThread:newThread withObject:nil waitUntilDone:YES];
// 这里指定为后台线程
[self performSelectorInBackground:@selector(threadRun) withObject:nil];

线程同步

线程和其他线程可能会共享一些资源, 当多个线程同时读写同一份共享资源的时候, 可能会引起冲突. 线程同步是指在一定的时间内只允许某一个线程访问某个资源.
iOS实现线程加锁有NSLock和@synchronized两种方式

线程的持续运行和退出

怎样能让线程一直运行呢?
答案就是给线程加上RunLoop

线程状态

线程是否完成

BOOL ret = [newThread isFinished];

线程是否被取消

BOOL ret = [newThread isCancelled];

线程是否正在执行

BOOL ret = [newThread isExecuting];

GCD

GCD全称是Grand Central Dispatch

优势

  • GCD是苹果公司为多核的并行运算提出的解决方案
  • GCD会自动利用更多的CPU内核(比如双核, 四核)
  • GCD会自动管理线程的生命周期(创建线程, 调度任务, 销毁线程)

核心概念 - 任务

任务: 执行什么操作, 任务有两种执行方式: 同步函数和异步函数

  • 同步函数(dispatch_sync)
    只能在当前线程中执行任务, 不具备开启新线程的能力,任务会立刻马上执行, 会阻塞当前线程并等待Block中的任务执行完毕, 然后当前线程才会继续往下运行.
  • 异步函数(dispatch_async)
    可以在新的线程中执行任务, 具备开启新线程的能力, 但不一定会开启新线程, 当前线程会直接往下执行, 不会阻塞当前线程.

核心概念 - 队列

队列: 用来存放任务, 分为串行队列和并行队列

  • 串行队列(Serial Dispatch Queue)
    让任务一个接着一个的执行, 一个任务执行完毕后再执行下一个任务

  • 并行队列(Concurrent Dispatch Queue)
    可以放多个任务并发, 同时执行(自动开启多个线程同时执行任务)
    并发功能只有在异步函数下才有效.

GCD使用步骤

  • 定制任务
    确定想做的事
  • 将任务添加到队列中
    GCD会自动将队列中的任务取出, 放到对应的线程中去执行, 任务的取出遵循FIFO原则: 先进先出, 后进后出

GCD的创建

队列的创建

     /*
     @param label#> C语言字符串, 用来标识 description#>
     @param attr#> 队列的类型 description#>
     并发队列: DISPATCH_QUEUE_CONCURRENT
     串行队列: DISPATCH_QUEUE_SERIAL 或者 NULL
     @return dispatch_queue_t
     */
dispatch_queue_t queue = dispatch_queue_create(const char * _Nullable label, dispatch_queue_attr_t  _Nullable attr);

创建串行队列

方法一:

dispatch_queue_t queue = dispatch_queue_create("com.pinyin", DISPATCH_QUEUE_SERIAL);

方法二:

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

创建并发队列

dispatch_queue_t queue = dispatch_queue_create("com.pinyin", DISPATCH_QUEUE_CONCURRENT);

全局并发队列

GCD默认提供了全局并发队列, 供整个应用使用, 可以无需手动创建

@param identifier#> 优先级 也可以直接填后面的数字 description#>
DISPATCH_QUEUE_PRIORITY_HIGH = 2 高
DISPATCH_QUEUE_PRIORITY_DEFAULT = 0 默认
DISPATCH_QUEUE_PRIORITY_LOW = (-2) 低
DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN 后台
@param flags#> 预留参数 0 description#>
@return dispatch_queue_t->全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

获得主队列

dispatch_queue_t queue = dispatch_get_main_queue();

任务的执行

队列在queue中, 任务在block块中.

  • 开启同步函数, 同步函数: 要求立刻马上开始执行
@param queue: 队列
@param block: 执行的任务
dispatch_sync(queue, ^ {
    // 执行任务
}
  • 开启异步函数, 异步函数: 等主线程执行完毕之后, 回过头开线程执行任务
@param queue: 队列
@param block: 执行的任务
dispatch_async(queue, ^{
    // 执行任务
}

任务和队列的组合

任务: 同步函数和异步函数
队列: 串行队列和并行队列

  • 异步函数+并发队列: 会开启新的线程, 并发执行
    dispatch_queue_t queue = dispatch_queue_create("com.pinyin", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"1------%@", [NSThread currentThread]);
    });

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

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

控制台打印:

GCD_OC[18856:17195716] 1------{number = 3, name = (null)}
GCD_OC[18856:17195718] 3------{number = 5, name = (null)}
GCD_OC[18856:17195717] 2------{number = 4, name = (null)}
  • 异步函数+串行队列: 会开启一条线程, 任务串行执行
    dispatch_queue_t queue = dispatch_queue_create("com.pinyin", NULL);
    dispatch_async(queue, ^{
        NSLog(@"1-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"2-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"3-----%@", [NSThread currentThread]);
    });

控制台打印

GCD_OC[19358:17243144] 1-----{number = 3, name = (null)}
GCD_OC[19358:17243144] 2-----{number = 3, name = (null)}
GCD_OC[19358:17243144] 3-----{number = 3, name = (null)}
  • 同步函数+并发队列: 不会开线程, 任务串行执行
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_sync(queue, ^{
        NSLog(@"1------%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"2------%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"3------%@", [NSThread currentThread]);
    });

控制台打印

GCD_OC[19682:17270377] 1------{number = 1, name = main}
GCD_OC[19682:17270377] 2------{number = 1, name = main}
GCD_OC[19682:17270377] 3------{number = 1, name = main}
  • 同步函数+串行队列: 不会开线程, 任务串行执行
    dispatch_queue_t queue = dispatch_queue_create("com.pinyin", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue, ^{
        NSLog(@"1-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"2-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"3-----%@", [NSThread currentThread]);
    });

控制台打印

GCD_OC[19875:17290416] 1-----{number = 1, name = main}
GCD_OC[19875:17290416] 2-----{number = 1, name = main}
GCD_OC[19875:17290416] 3-----{number = 1, name = main}
  • 异步函数+主队列: 不会开线程, 任务串行执行
 dispatch_async(dispatch_get_main_queue(), ^{
    NSLog(@"------%@", [NSThread currentThread]);
 });

控制台打印

GCD_OC[20048:17307951] ------{number = 1, name = main}
  • 同步函数+主队列 : 死锁
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"%@", [NSThread currentThread]);
    });

死锁原因
首先这是一个同步函数, 同步函数要求立刻马上执行, 我们把这个同步函数的任务加入到主队列, 同步函数代码块中的任务等待主队列任务执行完毕, 然后执行代码块的任务, 主队列在等代码块里的任务执行, 两个任务互相等待发生死锁, 将这个方法放入子线程中, 则不会发生死锁, 任务串行执行

总结

iOS多线程_第1张图片
15353511052679.png

同步函数和异步函数的执行顺序

同步函数: 立刻马上执行, 会阻塞当前线程

    dispatch_queue_t queue = dispatch_queue_create("com.pinyin", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"------start-------");
    dispatch_sync(queue, ^{
        NSLog(@"1------%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"2------%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"3------%@", [NSThread currentThread]);
    });
    NSLog(@"------end-------");

控制台打印

GCD_OC[20695:17385076] ------start-------
GCD_OC[20695:17385076] 1------{number = 1, name = main}
GCD_OC[20695:17385076] 2------{number = 1, name = main}
GCD_OC[20695:17385076] 3------{number = 1, name = main}
GCD_OC[20695:17385076] ------end-------

异步函数: 当前线程会直接往下执行, 不会阻塞当前线程

    dispatch_queue_t queue = dispatch_queue_create("com.pinyin", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"------start-------");
    dispatch_async(queue, ^{
        NSLog(@"1------%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"2------%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"3------%@", [NSThread currentThread]);
    });
    NSLog(@"------end-------");

控制台打印

GCD_OC[20804:17399341] ------start-------
GCD_OC[20804:17399341] ------end-------
GCD_OC[20804:17399604] 3------{number = 5, name = (null)}
GCD_OC[20804:17399605] 2------{number = 4, name = (null)}
GCD_OC[20804:17399607] 1------{number = 3, name = (null)}

GCD线程之间的通信

GCD线程间的通信很简单, 使用同步或异步函数, 传入主队列即可

dispatch_async(dispatch_get_global_queue(0, 0), ^{
    // 下载图片
    dispatch_async(dispatch_get_main_queue(), ^ {
         // 更新UI
    });
});

GCD常用函数

栅栏函数

  • 作用: 控制任务的执行顺序
dispatch_barrier_async(queue, ^{

}

    dispatch_queue_t queue = dispatch_queue_create("com.pinyin", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"1-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"2-----%@", [NSThread currentThread]);
    });
    dispatch_barrier_async(queue, ^{
        NSLog(@"我是栅栏函数");
    });
    dispatch_async(queue, ^{
        NSLog(@"3-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"4-----%@", [NSThread currentThread]);
    });

控制台打印

GCD_OC[21103:17426839] 2-----{number = 4, name = (null)}
GCD_OC[21103:17426841] 1-----{number = 3, name = (null)}
GCD_OC[21103:17426841] 我是栅栏函数
GCD_OC[21103:17426841] 3-----{number = 3, name = (null)}
GCD_OC[21103:17426839] 4-----{number = 4, name = (null)}

延迟执行

    /**
     延迟执行

     @param DISPATCH_TIME_NOW 延迟时间
     @param int64_t 要执行的代码
     @return 如果想要延迟的代码在子线程中执行, 可以将dispatch_get_main_queue()
     改为其他队列
     */
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"------%@", [NSThread currentThread]);
    });

一次性代码

一般用于单例

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 只执行一次的代码
    });

快速迭代

开启多个线程并发完成迭代操作

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    /**
     快速迭代

     @param 5 次数
     @param queue 在哪个队列中执行
     @param block 执行的Block
     */
    dispatch_apply(5, queue, ^(size_t i) {
        NSLog(@"dispatch_apply == == ==........... %lu", i);
    });

控制台打印

GCD_OC[21684:17472387] dispatch_apply == == ==........... 0
GCD_OC[21684:17473701] dispatch_apply == == ==........... 2
GCD_OC[21684:17473703] dispatch_apply == == ==........... 3
GCD_OC[21684:17473702] dispatch_apply == == ==........... 1
GCD_OC[21684:17472387] dispatch_apply == == ==........... 4

队列组

dispatch_group 创建一个任务组, 然后异步执行加入group的每个任务.
一般用于: 异步多请求

    dispatch_queue_t queue = dispatch_queue_create("com.pinyin", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, queue, ^{
        // 执行请求1
        NSLog(@"1------%@", [NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        // 执行请求2
        NSLog(@"2------%@", [NSThread currentThread]);
    });
    dispatch_group_notify(group, queue, ^{
        // 执行完毕, 可以在这里进行更新UI操作
        NSLog(@"finish----%@", [NSThread currentThread]);
    });

控制台打印

GCD_OC[22139:17507032] 1------{number = 3, name = (null)}
GCD_OC[22139:17506993] 2------{number = 4, name = (null)}
GCD_OC[22139:17506993] finish----{number = 4, name = (null)}

dispatch_group_async里的block执行的是异步任务, 如果还是使用上面的方法会发现, 在异步任务还没跑完就已经进入到了dispatch_group_notify方法了, 这时用dispatch_group_enter和dispatch_group_leave就可以解决这个问题.
解决方法:

    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_queue_create("com.pinyin", DISPATCH_QUEUE_CONCURRENT);
    // 进入组
    dispatch_group_enter(group);
    dispatch_group_async(group, queue, ^{
        // 网络请求1 异步代码块
        {
            // 离开组
            dispatch_group_leave(group);
        }
        NSLog(@"1-----%@", [NSThread currentThread]);
    });
    // 进入组
    dispatch_group_enter(group);
    dispatch_group_async(group, queue, ^{
        // 网络请求1 异步代码块
        {
            // 离开组
            dispatch_group_leave(group);
        }
        NSLog(@"2-----%@", [NSThread currentThread]);
    });
    dispatch_group_notify(group, queue, ^{
        // 获取到网络请求的数据, 更新UI
        NSLog(@"finish----%@", [NSThread currentThread]);
    });

控制台打印

GCD_OC[23625:17613380] 1-----{number = 3, name = (null)}
GCD_OC[23625:17613378] 2-----{number = 4, name = (null)}
GCD_OC[23625:17613378] finish----{number = 4, name = (null)}

NSOperation

NSOperation是苹果公司对GCD的封装, 完全面向对象, 并且比GCD多了一些简单使用的功能, 所以使用起来更加方便容易理解
优点:

  • 可添加完成的代码块, 在操作完成后执行
  • 添加操作之间的依赖关系, 方便的控制执行顺序
  • 设定操作执行的优先级
  • 可以很方便的取消一个操作的执行
  • 使用KVO观察对操作执行状态的更改:isExecuting, isFinished, isCancelled.

核心概念 - 操作(Operation)

相当于GCD的任务
执行操作的意思, 在GCD中是放在block中的, 在NSOperation中, 我们使用NSOperation的子类NSInvocationOperation, NSBlockOperation 或者自定义子类来封装操作.

核心概念 - 操作队列(Operation Queues)

NSOperation的操作队列和GCD的队列差不多, 都是用来存放操作(任务)的.

  • 不同于GCD的先进先出原则, NSOperationQueue对于添加到队列中的操作, 首先进入准备就绪的状态, 然后进入就绪状态的操作的开始执行顺序由操作之间相对的优先级决定
  • 操作队列通过设置最大并发操作数(maxConcurrentOperationCount)来控制并发, 串行
  • NSOperationQueue为我们提供了两种不同类型的队列: 主队列和自定义队列
    • 主队列: 运行在主线程之上
    • 自定义队列: 在后台执行

NSOperation, NSOperationQueue使用步骤

NSOperation要配合NSOperationQueue来实现多线程, 因为默认情况下, NSOperation单独使用时系统同步执行操作, 配合NSOperationQueue我们能更好的实现异步执行.

NSOperation实现多线程的使用步骤分为三步:

  • 创建操作: 先将需要执行的操作封装到一个NSOperation对象中
  • 创建队列: 创建NSOperationQueue对象
  • 将操作加入队列中: 将NSOperation对象添加到NSOperationQueue对象中

系统就会自动将NSOperationQueue中的NSOperation取出来, 在新线程中执行操作

创建操作(NSOperation)

NSOperation是一个抽象类, 不能用来封装操作, 我们只能使用它的子类来封装操作, 有三种方式来封装操作.

  • 使用子类NSInvocationOperation
  • 使用子类NSBlockOperation
  • 自定义继承自NSOperation的子类, 通过实现内部相应的方法来封装操作
NSInvocationOperation
- (void)viewDidLoad {
    [super viewDidLoad];
    // 创建NSInvocationOperation 对象
    NSInvocationOperation *opertaion = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task:) object:@"校长"];
    // 调用start方法 执行操作
    [opertaion start];
}

- (void)task:(NSString *)name {
    // 打印当前线程
    NSLog(@"%@", [NSThread currentThread]);
    NSLog(@"%@", name);
}

控制台打印

[53559:18598091] {number = 1, name = main}
[53559:18598091] 校长

可以看到在没有使用NSOperationQueue的情况下, 单独使用NSOperation子类, NSInvocationOperation执行一个操作的情况下, 并没有开启新的线程.

NSBlockOperation
    // 创建NSBlockOperation对象
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"%@", [NSThread currentThread]);
    }];
    // 执行操作
    [operation start];

控制台打印

{number = 1, name = main}

可以看到在没有使用NSOperationQueue, 在单独使用NSBlockOperation执行一个操作的情况下, 操作是当前线程执行的, 并没有开启新线程.

但是, NSBlockOperation还提供了一个方法addExecutionBlock, 通过addExecutionBlock就可以为NSBlockOperation添加额外的操作, 这些操作可以在不同的线程中并发执行, 只有当所有相关的操作已经完成执行时, 才视为完成.

    // 创建NSBlockOperation对象
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"1--------%@", [NSThread currentThread]);
    }];

    [operation addExecutionBlock:^{
        NSLog(@"2--------%@", [NSThread currentThread]);
    }];

    [operation addExecutionBlock:^{
        NSLog(@"3--------%@", [NSThread currentThread]);
    }];

    [operation addExecutionBlock:^{
        NSLog(@"5--------%@", [NSThread currentThread]);
    }];
    [operation addExecutionBlock:^{
        NSLog(@"6--------%@", [NSThread currentThread]);
    }];

    [operation addExecutionBlock:^{
        NSLog(@"7--------%@", [NSThread currentThread]);
    }];

    [operation addExecutionBlock:^{
        NSLog(@"8--------%@", [NSThread currentThread]);
    }];
    // 执行操作
    [operation start];

控制台打印

[54248:18665109] 3--------{number = 4, name = (null)}
[54248:18664485] 5--------{number = 5, name = (null)}
[54248:18664486] 2--------{number = 3, name = (null)}
[54248:18661846] 1--------{number = 1, name = main}
[54248:18664485] 7--------{number = 5, name = (null)}
[54248:18664486] 8--------{number = 3, name = (null)}
[54248:18665109] 6--------{number = 4, name = (null)}

可以看出, 使用子类NSBlockOperation, 并调用方法addExecutionBlock:的情况下, blockOperationWithBlock:和addExecutionBlock:中的操作是在不同的线程中异步执行的.

一般情况下, 如果一个NSBlockOperation对象封装了多个操作, NSBlockOperation是否开启新线程, 取决于操作的个数, 如果添加的操作的个数多, 就会自动开启新线程. 开启线程的个数由系统决定.

使用自定义继承自NSOperation的子类

如果使用子类NSInvocationOperation和NSBlockOperation都不能满足开发需求, 我们可以尝试使用自定义继承自NSOperation的子类. 可以通过重写main或start方法来自定义自己的NSOperation对象, 重写main方法比较简单, 我们不需要管理操作的状态属性isExecuting, isFinished. 当main执行返回的时候, 这个操作就结束了.
一个简单的

#import 

@interface MYOperation : NSOperation

@end

#import "MYOperation.h"

@implementation MYOperation
- (void)main {
    if (!self.isCancelled) {
        NSLog(@"MyOperation -- %@", [NSThread currentThread]);
    }
}
@end

导入头文件MYOperation.h

    MYOperation *operation = [[MYOperation alloc] init];
    [operation start];

控制台打印

 MyOperation -- {number = 1, name = main}

可以看出在没有使用NSOperationQueue, 单独使用自定义继承自NSOperation的子类的情况下, 并没有开启新线程

创建队列(NSOperationQueue)

NSOperationQueue有两种队列

  • 主队列
    • 添加到主队列的操作, 都会放到主线程去执行
  • 自定义队列
    • 添加到自定义队列的操作, 都会放到子线程中执行
    • 自定义队列包含了 串行和并发功能

获取主队列

[NSOperationQueue mainQueue];

自定义队列创建方法

NSOperationQueue *queue = [[NSOperationQueue alloc] init];

将操作加入队列中

NSOperation要配合NSOperationQueue来实现多线程, 那么需要将创建好的操作添加到队列中去.
两种方法:

  • - (void)addOperation:(NSOperation *)op;
    // 创建NSInvocationOperation任务对象
    NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task:) object:@"校长"];
    // 创建NSBlockOperation任务对象
    NSBlockOperation *blockOperaion = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"blockOperation -- %@", [NSThread currentThread]);
    }];
    // 创建自定义队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    // 将任务添加到队列中
    [queue addOperation:operation];
    [queue addOperation:blockOperaion];

- (void)task:(NSString *)name {
    // 打印当前线程
    NSLog(@"%@", [NSThread currentThread]);
    NSLog(@"%@", name);
}

控制台打印

[55782:18793884] blockOperation -- {number = 4, name = (null)}
[55782:18793886] task1 --- {number = 3, name = (null)}
[55782:18793886] task1 --- 校长

使用NSOperation子类创建操作, 并使用addOperation:将操作加入到操作队列后能够开启新线程, 进行并发执行.

  • - (void)addOperationWithBlock:(void (^)(void))block;
    addOperationWithBlock:无需创建操作, 在block中添加操作, 直接将包含操作的block加入到队列中.
    // 创建自定义队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    // 添加操作到队列中
    [queue addOperationWithBlock:^{
        NSLog(@"1-----%@", [NSThread currentThread]);
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"2-----%@", [NSThread currentThread]);
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"3-----%@", [NSThread currentThread]);
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"4-----%@", [NSThread currentThread]);
    }];

控制台打印

[56017:18816692] 3-----{number = 5, name = (null)}
[56017:18816689] 1-----{number = 4, name = (null)}
[56017:18816690] 4-----{number = 6, name = (null)}
[56017:18816691] 2-----{number = 3, name = (null)}

addOperationWithBlock:将操作加入到操作队列后能够开启新线程, 并发执行.

控制NSOperationQueue队列的串行, 并发

设置NSOperationQueue的串行和并发, 需要设置maxConcurrentOperationCount这个属性.
maxConcurrentOperationCount: 最大并发数, 用来控制一个自定义队列中可以有多少个操作同时执行.

  • 最大操作并发数: maxConcurrentOperationCount
    • 默认为-1: 表示不进行限制, 可进行并发执行
    • 1 : 队列为串行队列, 只能串行执行
    • 大于1: 队列为并发队列, 操作并发执行 (这个值不应该超过系统限制, 即使自己设置一个很大的值, 系统也会自动调整为min)
    // 创建自定义队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    // 设置最大操作数为 1
    queue.maxConcurrentOperationCount = 1;
    // 添加操作到队列中
    [queue addOperationWithBlock:^{
        NSLog(@"1-----%@", [NSThread currentThread]);
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"2-----%@", [NSThread currentThread]);
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"3-----%@", [NSThread currentThread]);
    }];

    [queue addOperationWithBlock:^{
        NSLog(@"4-----%@", [NSThread currentThread]);
    }];

控制台打印

  • 最大操作为1的结果
[56307:18843375] 1-----{number = 3, name = (null)}
[56307:18843377] 2-----{number = 4, name = (null)}
[56307:18843377] 3-----{number = 4, name = (null)}
[56307:18843377] 4-----{number = 4, name = (null)}

可以看到, 在maxConcurrentOperationCount为1时, 操作串行执行.

  • 最大操作为2的结果
[56491:18863093] 2-----{number = 4, name = (null)}
[56491:18863094] 1-----{number = 3, name = (null)}
[56491:18863092] 3-----{number = 5, name = (null)}
[56491:18863094] 4-----{number = 3, name = (null)}

可以看到, 任务不是串行执行的, 而是并发执行, 而开启线程数量是由系统决定的, 不需要我们来管理.

NSOperation操作依赖

NSOperation,NSOperationQueue最引人的地方就是它能添加操作之间的依赖关系.
通过操作依赖, 我们可以很方便的控制操作之间的执行先后顺序, NSOperation提供了3个接口供我们管理和查看依赖

  • - (void)addDependency:(NSOperation *)op;
    • 添加依赖, 使当前操作依赖于操作op的完成;
  • - (void)removeDependency:(NSOperation *)op;
    • 移除依赖, 取消当前操作对操作op的依赖
  • @property (readonly, copy) NSArray *dependencies;
    • 在当前操作开始执行之前完成执行的所有操作对象数组
操作依赖应用场景

有两个操作A操作和B操作, 要求A执行完毕后, B才能执行

    // 创建自定义队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    // 创建操作
    NSInvocationOperation *operationA = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task:) object:@"校长"];
    // 创建操作
    NSBlockOperation *operationB = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"operation B%@", [NSThread currentThread]);
    }];
    // 添加依赖
    // 要求: A执行完毕, 再执行B , 那就是B依赖于A的完成
    // 调用者 : 当前操作
    // 参数 :  被依赖对象
    // 这个方法的意思就是调用者依赖于参数的完成
    [operationB addDependency:operationA];

    // 添加操作到队列中
    [queue addOperation:operationA];
    [queue addOperation:operationB];

控制台打印

[56978:18909531] task1 --- {number = 3, name = (null)}
[56978:18909531] task1 --- 校长
[56978:18909530] operation B{number = 4, name = (null)}

可以发现, 通过添加依赖, Operation A 先执行, 然后再执行Operation B

NSOperation优先级

NSOperation提供了NSOperationQueuePriority队列优先级, 用来设置同一队列中的操作优先级.

// 从低到高排列
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
    NSOperationQueuePriorityVeryLow = -8L,
    NSOperationQueuePriorityLow = -4L,
    NSOperationQueuePriorityNormal = 0, // 默认优先级
    NSOperationQueuePriorityHigh = 4,
    NSOperationQueuePriorityVeryHigh = 8
};

可以通过[operationA setQueuePriority:NSOperationQueuePriorityLow];改变操作的优先级状态.

  • 什么是就绪状态?
    • 没有需要依赖的操作等待执行的状态叫做就绪状态. 有依赖的操作都不是准备就绪状态下的操作.
    • queuePriority属性决定了进入准备就绪状态下的操作之间的执行顺序, 并且, 优先级不能取代依赖关系

NSOperation, NSOperationQueue线程间的通信

    // 创建自定义队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
        // 异步执行耗时操作
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];
            NSLog(@"异步线程---%@", [NSThread currentThread]); // 打印当前线程
        }
        // 回到主线程
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            NSLog(@"回到主线程 --- %@", [NSThread currentThread]);
        }];
    }];
    // 将操作添加到队列中
    [queue addOperation:operation];

控制台打印

[58135:19050484] 异步线程---{number = 3, name = (null)}
[58135:19050484] 异步线程---{number = 3, name = (null)}
[58135:19048720] 回到主线程 --- {number = 1, name = main}

NSOperationQueue, NSOperation常用属性和方法总结

NSOPeration常用属性和方法
  1. 取消操作方法
    • -(void)cancel; 可以取消操作, 实质是标记isCancelled状态
  2. 判断操作状态方法
    • - (BOOl)isFinished; 判断操作是否已经结束
    • - (BOOL)isCancelled; 判断操作是否已经标记为取消
    • - (BOOL)isExecuting; 判断操作是否正在运行
    • - (BOOL)isReady; 判断操作是否处于准备就绪状态, 这个值和操作的依赖关系相关
  3. 操作同步
    • - (void)waitUntilFinished;阻塞当前线程, 直到该操作结束, 可用于线程执行顺序的同步.
    • - (void)setCompletionBlock:(void (^)(void))block;, completionBlock会在当前操作执行完毕时执行completionBlock
    • - (void)addDependency:(NSOperation *)op; 添加依赖
    • - (void)removeDependency:(NSOperation *)op; 移除依赖
    • @property (readonly, copy) NSArray *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组.
NSOperationQueue常用属性和方法
  1. 取消 暂停 恢复操作
    • - (void)cancelAllOperation; 取消队列内的所有操作
    • - (BOOL)isSuspended; 判断队列是否处于暂停状态, YES为暂停状态, NO为恢复状态
    • - (void)setSuspendes:(BOOL)b; 可设置操作的暂停和回复, YES代表暂停队列, NO代表恢复队列
  2. 操作同步
    • - (void)waitUntilAllOperationAreFinished; 阻塞当前线程, 直到队列中的操作全部执行完毕.
  3. 添加/获取操作
    • - (void_addOperationWithBlock:(void (^)(void))block;向队列中添加一个NSBlockOperation类型操作对象
    • - (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait; 向队列中添加操作数组, wait标志是否阻塞当前线程直到所有操作结束
    • - (NSArray *)operations; 当前在队列中的操作数组(某个操作执行结束后会自动从这个数组清除).
    • - (NSUInteger)operationCount; 当前队列中的操作数
  4. 获取队列
    • + (id)currentQueue; 获取当前队列, 如果当前线程不是在NSOperationQueue上运行则返回nil.
    • + (id)mainQueue; 获取主队列
问题 - 线程和队列又有什么区别

简单来说, 队列就是用来存放任务的暂存区, 而线程是执行任务的路径, GCD将这些存在于队列的任务取出来放到相应的线程上去执行, 而队列的性质决定了在其中的任务在哪种线程上执行.

iOS多线程_第2张图片
15353404897575.png

你可能感兴趣的:(iOS多线程)

  • 【iOS】GCD详解 cheng_lin0201 OCiOSiosobjective-c
    初识GCD深入理解GrandCentralDispatch(GCD)：iOS多线程编程的利器前言1.GCD简介1.1什么是GCD？1.2为什么使用GCD？2.GCD的核心概念2.1任务与队列2.2串行队列与并发队列3.GCD的API3.1DispatchQueue3.2dispatch_queue_create3.3MainDispatchQueue&GlobalDispatchQueue3.4d
  • iOS多线程基础 星辰流转轮回
    什么是进程?进程是指系统中正在运行的一个程序,每个进程间是独立的,每个进程均运行在其专用且受保护的内存空间内.什么是线程?一个进程想要执行任务,必须得有线程.(每一个进程至少要有一个线程)一个进程中的所有任务都在线程中执行线程的串行一个线程中的所有任务的执行顺序都是串行的,也就是说,在同一时间内,一个线程只能执行一个任务.只有执行完上一个任务才可以执行下一个;也可以任务,线程是进程中的一条执行路径
  • iOS多线程——概念与原理 iOS发呆君
    1.进程的定义进程是指在系统中正在运行的一个应用程序，在iOS系统中，每个进程之间都是独立的，每个进程都运行在其专用的且受保护的内存中。作为一个开发者，有一个学习的氛围跟一个交流圈子特别重要，这是一个我的iOS交流群：196800191，加群密码：112233，不管你是小白还是大牛欢迎入驻，分享BAT,阿里面试题、面试经验，讨论技术，大家一起交流学习成长！2.线程的定义线程是进程的基本执行单元，一
  • iOS多线程 - 死锁原因 L域
    Note:在同一个串行队列中执行同步操作会引发死锁。-(void)viewdidLoad{//在主线程中进行同步操作（主线程）dispatch_sync(dispatch_get_main_queue(),^{//dosomething});}要知道死锁的原因，首先要清楚并发、串行队列，异步和同步之间的区别：并发队列将任务(函数)分配到线程执行时，不需要等待函数的返回即可执行下一个任务串行队列需要
  • iOS多线程详解 爱看书de图图
      在iOS开发中，我们经常会使用到多线程技术，用于处理一些比较耗时的操作。在iOS中，有四种多线程的API，接下来我会带领大家一起去了解一下多线程相关的知识，以便帮助大家更好的使用多线程编程。下面先看一下四种API的比较：iOS中常见的多线程方案pthread：基于C语言，可以跨平台使用，需要程序员管理生命周期，使用难度大，所以不怎么使用NSThread：基于OC，面向对象，操作简单，需要程序员
  • 重温01-iOS多线程编程 那月无痕
    OC中的多线程OC中多线程根据封装程度可以分为三个层次：NSThread、GCD和NSOperation，另外由于OC兼容C语言，因此仍然可以使用C语言的POSIX接口来实现多线程，只需引入相应的头文件：#includeNSThreadNSThread是封装程度最小最轻量级的，使用更灵活，但要手动管理线程的生命周期、线程同步和线程加锁等，开销较大；NSThread的基本使用比较简单，可以动态创建初
  • iOS面试—0、技术点 weixin_30919235 面试runtimeswift
    初级：先简单自我介绍一下自己聊一聊过往项目中你觉得收获最大的一个模块。运行时：https://juejin.im/post/5ac0a6116fb9a028de44d717#heading-19多线程：iOS多线程：『pthread、NSThread』详尽总结iOS多线程：『GCD』详尽总结iOS多线程：『NSOperation、NSOperationQueue』详尽总结viewcontrolle
  • iOS多线程同步异步、串行并发浅析 guoguojianshu
    先来说一个队列和任务：队列分为串行队列与并行队列任务的执行分为同步执行与异步执行这两两组合就成为了串行队列同步执行，串行队列异步执行，并行队列同步执行，并行队列异步执行而异步是多线程的代名词，异步在实际引用中会开启新的线程，执行耗时操作。那我们先来知道一个非常重要的事情：1.队列只是负责任务的调度，而不负责任务的执行2.任务是在线程中执行的队列和任务的特点：队列的特点：先进先出，排在前面的任务最先
  • NSOperation queue? 小小鱼类
    存放NSOperation的集合类。操作和操作队列，基本可以看成java中的线程和线程池的概念。用于处理ios多线程开发的问题。网上部分资料提到一点是，虽然是queue，但是却并不是带有队列的概念，放入的操作并非是按照严格的先进现出。这边又有个疑点是，对于队列来说，先进先出的概念是Afunc添加进队列，Bfunc紧跟着也进入队列，Afunc先执行这个是必然的，但是Bfunc是等Afunc完全操作完
  • iOS多线程-RunLoop rainbowboy
    1、概念RunLoop与线程关联的，是一种事件处理环，用来安排和协调到来的事件，目的就是让其关联的线程在有事件到达时时刻保持运行状态，而当没有事件需要处理时进入睡眠状态从而节约资源，每一个线程都可以有一个RunLoop对象与之对应，并且是在第一次获取它是系统自动创建的，比如主线程关联的RunLoop，我们都知道程序的入口函数是main函数，下面是创建工程后Xcode自动生成的main.m文件的ma
  • 浅谈一种规避iOS多线程Crash的方案 酷爽 iOS
    一般来说，多线程编程因具有以下几个优点，一直被广泛应用：资源利用率更好程序设计在某些情况下更简单程序响应更快但是因为多线程而导致的crash问题，也是令程序员非常头疼的一个问题，因为线程调度执行顺序的不确定性，造成了crash一般都是小概率出现，在开发测试阶段很难发现，而一旦上线面对用户，造成的影响却是不容小觑的。一、Crash的场景有一种特别常见的会造成crash的场景为：多线程读写可变数组/字
  • GCD实现线程同步的方法 爱笑的猫mi
    在iOS多线程中我们知道NSOperationQueue操作队列可以直接使用addDependency函数设置操作之间的依赖关系实现线程同步，还可以使用setMaxConcurrentOperationCount函数直接设置最大并发数量。那么在GCD中又是如何实现线程同步和控制最大并发数量的呢？事实上在之前的问题中我们已经提到了GCD实现线程同步的两种方法了，一种是组队列（dispatch_gro
  • iOS多线程学习小记『GCD的API之dispatch_suspend/dispatch_resume』 达若漠沙
    3.2.10dispatch_suspend/dispatch_resume当追加大量处理到DispatchQueue时,在追加处理的过程中，有时希望不执行已追加的处理。例如验算结果被Block截获时，一些处理会对这个验算结果造成影响。在这种情况下，只要挂起DispatchQueue即可。当可以执行时再恢复。dispatch_suspend函数挂起指定的DispatchQueue.dispatch
  • IOS - @synchronized详解 Typeco
    本文首发于个人博客在IOS开发中，同步锁相信大家都使用过，即@synchronized,这篇文章向大家介绍一些@synchronized的原理和使用。@synchronized原理@synchronized是IOS多线程同步中性能最差的:却是使用起来最方便的一个，通常我们这么用：@synchronized(self){//code}为了了解其底层是如何实现的，我们在测试工程的ViewControl
  • iOS多线程之超实用理论+demo演示（可下载） Dast1Woop
    [toc]背景简介在初学iOS相关知识过程中，大多都对多线程有些恐惧的心里，同时感觉工作中用上的概率不大。但是如果平时不多积累并学透多线程，当工作中真的需要用到的时候，就很可能简单百度后把一些知识点稀里糊涂地就用到工作中了，殊不知里面有很多的坑，也有很多技巧需要在理论上先做了解，再结合实战，进一步去体会多线程的魅力和强大。接下来，就对多线程来源的背景进行简单的介绍：在计算的早期，计算机可以执行的最
  • 多线程基础 浪的出名
    什么是线程、多线程？在学习iOS多线程应用之前，我们先来学习一下什么是线程？线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程的实际运作单位，一条线程指的是进程中一个单一顺序的控制流。系统中正在运行的每一个应用程序都是一个进程，系统会为每个进程分配独立的内存空间。而一个进程中的所有任务都是在线程中执行的，因此每个进程至少得有一个线程，这也就是我们平常所说的主线程。一个进程可以开启
  • iOS多线程之pthread的简单使用 Mr_fei
    前言pthread是c语言编写的,基本用不到,了解一下就好.线程创建代码第一步:先导入#import第二步:创建线程//参数一:线程地址//参数二:线程属性//参数三:指向函数的指针//参数四:函数参数pthread_tpthread;pthread_create(&pthread,NULL,test,NULL);void*(test)(void*param){NSLog(@"%@",[NSThr
  • iOS多线程编程 红太羊_8225
    OC中的多线程OC中多线程根据封装程度可以分为三个层次：NSThread、GCD和NSOperation，另外由于OC兼容C语言，因此仍然可以使用C语言的POSIX接口来实现多线程，只需引入相应的头文件：#include。NSThreadNSThread是封装程度最小最轻量级的，使用更灵活，但要手动管理线程的生命周期、线程同步和线程加锁等，开销较大；NSThread的基本使用比较简单，可以动态创建
  • iOS多线程——pthread、NSThread 不学会Core Data不改名 ioscocoamacosobjective-c
    pthreadNSThread多线程的常见方案pthreadpthread简介pthread使用方法pthread其他相关方法NSThread创建、启动线程线程相关用法线程状态控制方法线程之间的通信NSThread线程安全和线程同步NSThread非线程安全NSThread线程安全多线程的常见方案技术方案特点使用语言线程生命周期使用频率pthread一套通用的多线程API适用于Windows/Li
  • iOS 多线程 可地出溜
    前言：这可能是史上最全面的一篇iOS多线程博客了（王婆卖瓜一番），从多线程的基本概念，进程的概念，引出iOS中的四种多线程方案pthread、NSThread、NSOperation和GCD，每一部分都有详细的代码和解释说明；在GCD中，引出同步、异步、串行队列（包括主队列）和并发队列概念，并对他们的六种组合进行详细的代码验证和说明，把这些概念安排的明明白白，然后详细的说明了GCD常见的其他用法；
  • iOS多线程 雪丹妮_66865
    进程：进程是指在系统中正在运行的一个应用程序每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内线程：1个进程要想执行任务，必须得有线程(每1个进程至少要有1条线程)一个进程(程序)的所有任务都在线程中执行进程和线程的比较1.线程是CPU调用(执行任务)的最小单位2.进程是CPU分配资源和调度的单位3.一个程序可以对应多个进程，一个进程中可以有多个线程，但至少要有一个线程4.同一个进程
  • iOS多线程：『GCD』详尽总结 林希品
    行走的少年郎关注2016.09.0319:47*字数10492阅读41799评论91喜欢504image.png本文首发于我的个人博客：『不羁阁』文章链接：传送门本文更新时间：2018-02-2410:07:40感谢大家对这篇文章的喜欢和支持。为了不辜负大家的喜欢，也为了更好的让大家了解iOS多线程，以及GCD的相关知识，我对这篇文章进行了重新梳理，在原有文章的基础上修改了原文存在的问题，并增加了
  • iOS多线程-GCD的常见用法 学习天亦
    复习下线程的基础知识，这里主要是参考文顶顶多线程篇复习写的。1、线程间通信示例从子线程回到主线程#import"ViewController.h"@interfaceViewController()@property(strong,nonatomic)UIImageView*imageView;@end@implementationViewController-(void)viewDidLoad{
  • iOS多线程 - GCD中的栅栏函数 赑屃王者
    一、什么是栅栏函数dispatch_barrier_async函数，在进程管理中起到一个栅栏的作用，它等待所有位于barrier函数之前的操作执行完毕后执行,并且在barrier函数执行之后,barrier函数之后的操作才会得到执行，该函数需要同dispatch_queue_create函数生成的DISPATCH_QUEUE_CONCURRENT队列一起使用。二、dispatch_barrier_
  • 谈谈iOS多线程的锁 KingWorld
    image前言iOS开发中由于各种第三方库的高度封装，对锁的使用很少，刚好之前面试中被问到的关于并发编程锁的问题，都是一知半解，于是决定整理一下关于iOS中锁的知识，为大家查缺补漏。目录第一部分：什么是锁第二部分：锁的分类第三部分：性能对比第四部分：常见的死锁第五部分：总结(附Demo)正文一、什么是锁在过去几十年并发研究领域的出版物中，锁总是扮演着坏人的角色，锁背负的指控包括引起死锁、锁封护（l
  • iOS多线程(二) 大虾咪
    常见问题解惑1.问题一1.1以下代码打印结果-(void)viewDidLoad{[superviewDidLoad];dispatch_queue_tqueue=dispatch_queue_create("myqueue",DISPATCH_QUEUE_CONCURRENT);dispatch_async(queue,^{NSLog(@"task1");[selfperformSelector
  • 472,iOS多线程NSOperation 与 GCD的区别(面试点：GCD 和 NSOperation的区别主要表现在以下几方面: 1) GCD是一套 C 语言API,执行和操作简单高效，因... 枫叶1234
    GCD和NSOperation的区别主要表现在以下几方面:1)GCD是一套C语言API,执行和操作简单高效，因此NSOperation底层也通过GCD实现，这是他们之间最本质的区别.因此如果希望自定义任务，建议使用NSOperation；依赖关系，NSOperation可以设置操作之间的依赖(可以跨队列设置)，GCD无法设置依赖关系，不过可以通过同步来实现这种效果；3)KVO(键值对观察)，NSO
  • iOS多线程之pthread CoderJay
    什么是pthreadPOSIX线程（POSIXthreads），简称Pthreads，是线程的POSIX标准。该标准定义了创建和操纵线程的一整套API。在类Unix操作系统（Unix、Linux、MacOSX等）中，都使用Pthreads作为操作系统的线程。pthread的使用一般情况在iOS开发中我们很少使用pthread来创建线程，pthread常见跨平台框架中多线程创建。pthread是c语
  • iOS多线程-NSOperation基本操作 学习天亦
    复习下线程的基础知识，这里主要是参考文顶顶多线程篇复习写的。一、并发数（1）并发数:同时执⾏行的任务数.比如,同时开3个线程执行3个任务,并发数就是3（2）最大并发数：同一时间最多只能执行的任务的个数。（3）最⼤大并发数的相关⽅方法-(NSInteger)maxConcurrentOperationCount;-(void)setMaxConcurrentOperationCount:(NSInt
  • iOS多线程的锁,你知道多少？ iOS__开发者皮皮峰
    前言iOS开发中由于各种第三方库的高度封装，对锁的使用很少，刚好之前面试中被问到的关于并发编程锁的问题，都是一知半解，于是决定整理一下关于iOS中锁的知识，为大家查缺补漏。目录第一部分：什么是锁第二部分：锁的分类第三部分：性能对比第四部分：常见的死锁第五部分：总结(附Demo)正文一、什么是锁在过去几十年并发研究领域的出版物中，锁总是扮演着坏人的角色，锁背负的指控包括引起死锁、锁封护（luyang
  • 多线程编程之join()方法 周凡杨 javaJOIN多线程编程线程
    现实生活中，有些工作是需要团队中成员依次完成的，这就涉及到了一个顺序问题。现在有T1、T2、T3三个工人，如何保证T2在T1执行完后执行，T3在T2执行完后执行？问题分析：首先问题中有三个实体，T1、T2、T3， 因为是多线程编程，所以都要设计成线程类。关键是怎么保证线程能依次执行完呢？   Java实现过程如下： public class T1 implements Runnabl
  • java中switch的使用 bingyingao javaenumbreakcontinue
    java中的switch仅支持case条件仅支持int、enum两种类型。 用enum的时候，不能直接写下列形式。 switch (timeType) { case ProdtransTimeTypeEnum.DAILY: break; default: br
  • hive having count 不能去重 daizj hive去重having count计数
    hive在使用having count()是，不支持去重计数   hive (default)> select imei from t_test_phonenum where ds=20150701 group by imei having count(distinct phone_num)>1 limit 10;  FAILED: SemanticExcep
  • WebSphere对JSP的缓存 周凡杨 WAS JSP 缓存
          对于线网上的工程，更新JSP到WebSphere后，有时会出现修改的jsp没有起作用，特别是改变了某jsp的样式后，在页面中没看到效果，这主要就是由于websphere中缓存的缘故，这就要清除WebSphere中jsp缓存。要清除WebSphere中JSP的缓存，就要找到WAS安装后的根目录。        现服务
  • 设计模式总结 朱辉辉33 java设计模式
    1.工厂模式   1.1 工厂方法模式 (由一个工厂类管理构造方法)      1.1.1普通工厂模式(一个工厂类中只有一个方法)      1.1.2多工厂模式(一个工厂类中有多个方法)      1.1.3静态工厂模式(将工厂类中的方法变成静态方法) &n
  • 实例：供应商管理报表需求调研报告 老A不折腾 finereport报表系统报表软件信息化选型
    引言 随着企业集团的生产规模扩张，为支撑全球供应链管理，对于供应商的管理和采购过程的监控已经不局限于简单的交付以及价格的管理，目前采购及供应商管理各个环节的操作分别在不同的系统下进行，而各个数据源都独立存在，无法提供统一的数据支持；因此，为了实现对于数据分析以提供采购决策，建立报表体系成为必须。 业务目标 1、通过报表为采购决策提供数据分析与支撑 2、对供应商进行综合评估以及管理，合理管理和
  • mysql 林鹤霄
    转载源：http://blog.sina.com.cn/s/blog_4f925fc30100rx5l.html mysql -uroot -p ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: YES)   [root@centos var]# service mysql
  • Linux下多线程堆栈查看工具(pstree、ps、pstack) aigo linux
    原文：http://blog.csdn.net/yfkiss/article/details/6729364   1. pstree pstree以树结构显示进程$ pstree -p work | grep adsshd(22669)---bash(22670)---ad_preprocess(4551)-+-{ad_preprocess}(4552)  &n
  • html input与textarea 值改变事件 alxw4616 JavaScript
    // 文本输入框(input) 文本域(textarea)值改变事件 // onpropertychange(IE) oninput(w3c) $('input,textarea').on('propertychange input', function(event) {      console.log($(this).val()) });  
  • String类的基本用法 百合不是茶 String
      字符串的用法;     // 根据字节数组创建字符串 byte[] by = { 'a', 'b', 'c', 'd' }; String newByteString = new String(by);         1,length()  获取字符串的长度     &nbs
  • JDK1.5 Semaphore实例 bijian1013 javathreadjava多线程Semaphore
    Semaphore类        一个计数信号量。从概念上讲，信号量维护了一个许可集合。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。 S
  • 使用GZip来压缩传输量 bijian1013 javaGZip
            启动GZip压缩要用到一个开源的Filter：PJL Compressing Filter。这个Filter自1.5.0开始该工程开始构建于JDK5.0，因此在JDK1.4环境下只能使用1.4.6。         PJL Compressi
  • 【Java范型三】Java范型详解之范型类型通配符 bit1129 java
        定义如下一个简单的范型类，   package com.tom.lang.generics; public class Generics<T> { private T value; public Generics(T value) { this.value = value; } }
  • 【Hadoop十二】HDFS常用命令 bit1129 hadoop
    1. 修改日志文件查看器   hdfs oev -i edits_0000000000000000081-0000000000000000089 -o edits.xml cat edits.xml   修改日志文件转储为xml格式的edits.xml文件，其中每条RECORD就是一个操作事务日志   2. fsimage查看HDFS中的块信息等 &nb
  • 怎样区别nginx中rewrite时break和last ronin47
    在使用nginx配置rewrite中经常会遇到有的地方用last并不能工作，换成break就可以，其中的原理是对于根目录的理解有所区别，按我的测试结果大致是这样的。 location /    {         proxy_pass http://test; 
  • java-21.中兴面试题 输入两个整数 n 和 m ，从数列 1 ， 2 ， 3.......n 中随意取几个数 , 使其和等于 m bylijinnan java
    import java.util.ArrayList; import java.util.List; import java.util.Stack; public class CombinationToSum { /* 第21 题 2010 年中兴面试题 编程求解： 输入两个整数 n 和 m ，从数列 1 ， 2 ， 3.......n 中随意取几个数 , 使其和等
  • eclipse svn 帐号密码修改问题 开窍的石头 eclipseSVNsvn帐号密码修改
    问题描述：      Eclipse的SVN插件Subclipse做得很好，在svn操作方面提供了很强大丰富的功能。但到目前为止，该插件对svn用户的概念极为淡薄，不但不能方便地切换用户，而且一旦用户的帐号、密码保存之后，就无法再变更了。 解决思路：      删除subclipse记录的帐号、密码信息，重新输入
  • [电子商务]传统商务活动与互联网的结合 comsci 电子商务
          某一个传统名牌产品，过去销售的地点就在某些特定的地区和阶层，现在进入互联网之后，用户的数量群突然扩大了无数倍，但是，这种产品潜在的劣势也被放大了无数倍，这种销售利润与经营风险同步放大的效应，在最近几年将会频繁出现。。。。        如何避免销售量和利润率增加的
  • java 解析 properties-使用 Properties-可以指定配置文件路径 cuityang javaproperties
    #mq xdr.mq.url=tcp://192.168.100.15:61618; import java.io.IOException; import java.util.Properties; public class Test { String conf = "log4j.properties"; private static final
  • Java核心问题集锦 darrenzhu java基础核心难点
    注意，这里的参考文章基本来自Effective Java和jdk源码 1)ConcurrentModificationException 当你用for each遍历一个list时，如果你在循环主体代码中修改list中的元素，将会得到这个Exception，解决的办法是： 1)用listIterator, 它支持在遍历的过程中修改元素， 2)不用listIterator, new一个
  • 1分钟学会Markdown语法 dcj3sjt126com markdown
    markdown 简明语法 基本符号 *,-,+ 3个符号效果都一样，这3个符号被称为 Markdown符号 空白行表示另起一个段落 `是表示inline代码，tab是用来标记 代码段，分别对应html的code，pre标签 换行 单一段落( <p>) 用一个空白行 连续两个空格 会变成一个 <br> 连续3个符号，然后是空行
  • Gson使用二（GsonBuilder） eksliang jsongsonGsonBuilder
    转载请出自出处：http://eksliang.iteye.com/blog/2175473 一.概述     GsonBuilder用来定制java跟json之间的转换格式   二.基本使用 实体测试类： 温馨提示：默认情况下@Expose注解是不起作用的,除非你用GsonBuilder创建Gson的时候调用了GsonBuilder.excludeField
  • 报ClassNotFoundException: Didn't find class "...Activity" on path: DexPathList gundumw100 android
    有一个工程，本来运行是正常的，我想把它移植到另一台PC上，结果报： java.lang.RuntimeException: Unable to instantiate activity ComponentInfo{com.mobovip.bgr/com.mobovip.bgr.MainActivity}: java.lang.ClassNotFoundException: Didn't f
  • JavaWeb之JSP指令 ihuning javaweb
      要点   JSP指令简介  page指令  include指令    JSP指令简介    JSP指令（directive）是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分。 JSP指令的基本语法格式： <%@ 指令 属性名="
  • mac上编译FFmpeg跑ios 啸笑天 ffmpeg
    1、下载文件：https://github.com/libav/gas-preprocessor， 复制gas-preprocessor.pl到/usr/local/bin/下， 修改文件权限：chmod 777 /usr/local/bin/gas-preprocessor.pl 2、安装yasm-1.2.0 curl http://www.tortall.net/projects/yasm
  • sql mysql oracle中字符串连接 macroli oraclesqlmysqlSQL Server
    有的时候，我们有需要将由不同栏位获得的资料串连在一起。每一种资料库都有提供方法来达到这个目的： MySQL: CONCAT() Oracle: CONCAT(), || SQL Server: + CONCAT() 的语法如下： Mysql 中 CONCAT(字串1, 字串2, 字串3, ...): 将字串1、字串2、字串3，等字串连在一起。 请注意，Oracle的CON
  • Git fatal: unab SSL certificate problem: unable to get local issuer ce rtificate qiaolevip 学习永无止境每天进步一点点git纵观千象
    // 报错如下： $ git pull origin master fatal: unable to access 'https://git.xxx.com/': SSL certificate problem: unable to get local issuer ce rtificate   // 原因： 由于git最新版默认使用ssl安全验证，但是我们是使用的git未设
  • windows命令行设置wifi surfingll windowswifi笔记本wifi
    还没有讨厌无线wifi的无尽广告么，还在耐心等待它慢慢启动么 教你命令行设置 笔记本电脑wifi： 1、开启wifi命令 netsh wlan set hostednetwork mode=allow ssid=surf8 key=bb123456 netsh wlan start hostednetwork pause 其中pause是等待输入，可以去掉 2、
  • Linux（Ubuntu）下安装sysv-rc-conf wmlJava linuxubuntusysv-rc-conf
    安装：sudo apt-get install sysv-rc-conf 使用：sudo sysv-rc-conf 操作界面十分简洁，你可以用鼠标点击，也可以用键盘方向键定位，用空格键选择，用Ctrl+N翻下一页，用Ctrl+P翻上一页，用Q退出。     背景知识 sysv-rc-conf是一个强大的服务管理程序，群众的意见是sysv-rc-conf比chkconf
  • svn切换环境，重发布应用多了javaee标签前缀 zengshaotao javaee
    更换了开发环境，从杭州，改变到了上海。svn的地址肯定要切换的，切换之前需要将原svn自带的.svn文件信息删除，可手动删除，也可通过废弃原来的svn位置提示删除.svn时删除。   然后就是按照最新的svn地址和规范建立相关的目录信息，再将原来的纯代码信息上传到新的环境。然后再重新检出，这样每次修改后就可以看到哪些文件被修改过，这对于增量发布的规范特别有用。   检出
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他