西门吹水Jacky
西门吹水Jacky

NSOperation和NSOperationQueue学习总结

swift4.0版

1. NSOperation、NSOperationQueue 简介

NSOperation、NSOperationQueue 是苹果提供给我们的一套多线程解决方案。实际上 NSOperation、NSOperationQueue 是基于 GCD 更高一层的封装，完全面向对象。

GCD vs NSOperation Queue
GCD vs NSOperation Queue.png

我们可以看到，NSOperation Queue 作为高级 API，有很多 GCD 没有的功能，如需要支持：控制并发数、取消、添加依赖关系等需要使用 NSOperation Queue。
另外，由于 block 可复用性没有 NSOperation 好，对于独立性强、可复用性高的任务建议使用 NSOperation 实现。
当然，NSOperation 在使用时需要 sub-classing，工作量较大，对于简单的任务使用 GCD 即可
NSThread就更少用了，对于实时性要求很高的任务则可以使用 NSThread

2. NSOperation、NSOperationQueue 操作和操作队列

既然是基于 GCD 的更高一层的封装。那么，GCD 中的一些概念同样适用于 NSOperation、NSOperationQueue。在 NSOperation、NSOperationQueue 中也有类似的任务（操作）和 队列（操作队列） 的概念。

  • 操作（Operation）
    在 GCD 中是放在 block 中的。在 NSOperation 中，我们使用 NSOperation 子类 NSInvocationOperation、NSBlockOperation，或者自定义子类来封装操作。
  • 操作队列（Operation Queues）
    1.用来存放操作的队列。不同于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue 对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。
    2.操作队列通过设置 最大并发操作数（maxConcurrentOperationCount） 来控制并发、串行
    3.NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行

3. NSOperation、NSOperationQueue 使用步骤

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

  • 1.创建操作：先将需要执行的操作封装到一个 NSOperation 对象中。
  • 2.创建队列：创建 NSOperationQueue 对象。
  • 3.将操作加入到队列中：将 NSOperation 对象添加到 NSOperationQueue 对象中。

之后呢，系统就会自动将 NSOperationQueue 中的 NSOperation 取出来，在新线程中执行操作。

4.NSOperation 和 NSOperationQueue 基本使用

4.1 创建操作

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

  • 1.使用子类 NSInvocationOperation(swift已废弃)
  • 2.使用子类 NSBlockOperation
  • 3.自定义继承自 NSOperation 的子类，通过实现内部相应的方法来封装操作

在不使用 NSOperationQueue，单独使用 NSOperation 的情况下系统同步执行操作:

4.1.1 使用子类 NSBlockOperation
    /**
    * 使用子类 BlockOperation
    */
    func useBlockOperation(){
        let op = BlockOperation.init {
            for _ in 0...2{
                sleep(2)
                print("1---\(Thread.current)")
            }
        }
        
        op.start()
        print("main---\(Thread.current)")
    }

输出：
1---{number = 1, name = main}
1---{number = 1, name = main}
1---{number = 1, name = main}
main---{number = 1, name = main}

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

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

/**
    * 使用子类 BlockOperation
    * 调用方法 AddExecutionBlock:
    */
    @objc func useBlockOperationAddExecutionBlock(){
        
        //  1.创建 BlockOperation 对象
        let op = BlockOperation.init {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 2)
                print("1---\(Thread.current)")
            }
        }
        
        //  2.添加额外的操作
        op.addExecutionBlock {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 2)
                print("2---\(Thread.current)")
            }
        }
        
        op.addExecutionBlock {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 2)
                print("3---\(Thread.current)")
            }
        }

        op.addExecutionBlock {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 2)
                print("4---\(Thread.current)")
            }
        }
        
        op.start()
        print("current---\(Thread.current)")
    }

输出：
2---{number = 4, name = (null)}
1---{number = 1, name = main}
1---{number = 1, name = main}
2---{number = 4, name = (null)}
1---{number = 1, name = main}
2---{number = 4, name = (null)}
4---{number = 4, name = (null)}
3---{number = 1, name = main}
4---{number = 4, name = (null)}
3---{number = 1, name = main}
3---{number = 1, name = main}
4---{number = 4, name = (null)}
current---{number = 1, name = main}

如果一个 blockOperation 封装了多个操作，在主线程执行，系统只分配多一个线程与主线程来共同并发，且阻塞当前线程。这里与 objective-c 有差别，objective-c 是添加的操作的个数多，就会自动开启新线程。

如果是在其他线程上执行看下输出：

Thread.detachNewThreadSelector(#selector(useBlockOperationAddExecutionBlock), toTarget: self, with: nil)

输出：
2---{number = 6, name = (null)}
1---{number = 5, name = (null)}
2---{number = 6, name = (null)}
1---{number = 5, name = (null)}
2---{number = 6, name = (null)}
1---{number = 5, name = (null)}
3---{number = 6, name = (null)}
4---{number = 5, name = (null)}
3---{number = 6, name = (null)}
4---{number = 5, name = (null)}
3---{number = 6, name = (null)}
4---{number = 5, name = (null)}
current---{number = 5, name = (null)}

如果一个 blockOperation 封装了多个操作，在其他线程执行，系统只分配两条线程并发。

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

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

//
//  CustomOperation.swift
//

import UIKit

class CustomOperation: Operation {
    
    override func main() {
        if self.isCancelled == false{
            for _ in 0...2 {
                Thread.sleep(forTimeInterval: 2)
                print("1---\(Thread.current)")
            }
        }
    }

}

然后使用：

 /**
    * 使用自定义继承自 Operation 的子类
    */
    func useCustomOperation(){
        let op = CustomOperation.init()
        op.start()
    }

输出：
1---{number = 1, name = main}
1---{number = 1, name = main}
1---{number = 1, name = main}

另外一种方式是重写NSOperation的start方法，这种方法就需要你自己去控制NSOperation的完成，取消，执行等。通过官方文档可以知道，实现并行的自定义子类，需要重写以下几种方法或属性：

  • start：把需要执行的任务放在start方法里，并且要检查任务是否已取消，更新任务的状态等。(注意：任何时候都不能调用父类的start方法)
  • asynchronous：表示是否并发执行
  • executing：表示任务是否正在执行，需要手动调用KVO方法来进行通知，方便其他类监听了任务的该属性
  • finished：表示任务是否结束，需要手动调用KVO方法来进行通知，变量也需要监听改属性的值，用于判断任务是否结束
class CustomOperation: Operation {
    
    var _finished:Bool = false
    var _executing:Bool = false
    
    override var isExecuting: Bool{
        set{
            self.willChangeValue(forKey: "isExecuting")
            _executing = newValue
            self.didChangeValue(forKey: "isExecuting")
        }
        get{
            return _executing
        }
    }
    
    override var isFinished: Bool{
        set{
            self.willChangeValue(forKey: "isFinished")
            _finished = newValue
            self.didChangeValue(forKey: "isFinished")
        }
        get{
            return _finished
        }
    }
    
    override var isConcurrent: Bool{
        get{ return true }
    }
    
    override func start() {
        synchronized(self) {//线程安全
            if self.isCancelled{
                self.isFinished = true
                return
            }
            self.isExecuting = true//设置执行状态并调用KVO通知
            Thread.sleep(forTimeInterval: 2)//耗时操作：图片下载等.
            print("耗时操作: --- \(Thread.current)")
            self.isFinished = true//设置完成状态并调用KVO通知
        }
    }
    
     synchronized(_ lock: AnyObject, _ action: () -> Void){
        objc_sync_enter(lock)
        defer { objc_sync_exit(lock) }
        action()
    }
}

    func useCustomOperation(){
        let op1 = CustomOperation.init()
        let op2 = CustomOperation.init()
        
        let queue = OperationQueue.init()
        queue.addOperation(op1)
        queue.addOperation(op2)
    }

输出：
耗时操作: --- {number = 4, name = (null)}
耗时操作: --- {number = 5, name = (null)}

关于自定义NSOperation，可以阅读SDWebImage 的 SDWebImageDownloaderOperation 和 SDWebImageDownloader源码来学习更多知识

4.1 创建队列

NSOperationQueue 一共有两种队列：主队列、自定义队列

  • 主队列
    凡是添加到主队列中的操作，都会放到主线程中执行

      // 主队列获取方法
  let queue = OperationQueue.main

  • 自定义队列
    添加到这种队列中的操作，就会自动放到子线程中执行
    同时包含了串行、并发功能

      // 自定义队列创建方法
  let queue = OperationQueue.init()
4.3 将操作加入到队列中

NSOperation 配合 NSOperationQueue 来实现多线程
那么我们需要将创建好的操作加入到队列中去。总共有两种方法：
1.open func addOperation(_ op: Operation)需要先创建操作，再将创建好的操作加入到创建好的队列中去

    /**
    * 使用 addOperation: 将操作加入到操作队列中
    */
    func addOperationToQueue(){
        // 自定义队列创建方法
        let queue = OperationQueue.init()
        
        //  1.创建 BlockOperation 对象
        let op = BlockOperation.init {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 1)
                print("1---\(Thread.current)")
            }
        }
        
        let op1 = BlockOperation.init {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 1)
                print("1---\(Thread.current)")
            }
        }
        
        let op2 = BlockOperation.init {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 1)
                print("1---\(Thread.current)")
            }
        }
        
        queue.addOperation(op)
        queue.addOperation(op1)
        queue.addOperation(op2)
        print("current---\(Thread.current)")
    }

输出：
current---{number = 1, name = main}
1---{number = 5, name = (null)}
1---{number = 3, name = (null)}
1---{number = 6, name = (null)}
1---{number = 5, name = (null)}
1---{number = 6, name = (null)}
1---{number = 3, name = (null)}
1---{number = 5, name = (null)}
1---{number = 6, name = (null)}
1---{number = 3, name = (null)}

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

2.open func addOperation(_ block: @escaping () -> Void)无需先创建操作，在 block 中添加操作，直接将包含操作的 block 加入到队列中

    /**
    * 使用 addOperationWithBlock: 将操作加入到操作队列中
    */
    func addOperationWithBlockToQueue(){
        // 自定义队列创建方法
        let queue = OperationQueue.init()
        
        queue.addOperation {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 1)
                print("1---\(Thread.current)")
            }
        }
        
        queue.addOperation {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 1)
                print("2---\(Thread.current)")
            }
        }
        
        queue.addOperation {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 1)
                print("3---\(Thread.current)")
            }
        }
        print("current---\(Thread.current)")
    }

输出：
current---{number = 1, name = main}
1---{number = 4, name = (null)}
2---{number = 6, name = (null)}
3---{number = 5, name = (null)}
3---{number = 5, name = (null)}
2---{number = 6, name = (null)}
1---{number = 4, name = (null)}
2---{number = 6, name = (null)}
3---{number = 5, name = (null)}
1---{number = 4, name = (null)}

使用 addOperation 将操作加入到操作队列后能够开启新线程，进行并发执行

5.NSOperationQueue 控制串行执行、并发执行

NSOperationQueue是通过maxConcurrentOperationCount属性来控制串行执行、并发执行的
maxConcurrentOperationCount：叫做最大并发操作数。用来控制一个特定队列中可以有多少个操作同时参与并发执行。

  • maxConcurrentOperationCount 默认情况下为-1，表示不进行限制，可进行并发执行
  • maxConcurrentOperationCount 为1时，队列为串行队列。只能串行执行。
  • maxConcurrentOperationCoun 大于1时，队列为并发队列。操作并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整为 min{自己设定的值，系统设定的默认最大值}。

注意：这里 maxConcurrentOperationCount 控制的不是并发线程的数量，而是一个队列中同时能并发执行的最大操作数。而且一个操作也并非只能在一个线程中运行。

    /**
    * 设置 MaxConcurrentOperationCount（最大并发操作数）
    */
    func setMaxConcurrentOperationCount(){
        // 自定义队列创建方法
        let queue = OperationQueue.init()
        queue.maxConcurrentOperationCount = 1//串行队列
//        queue.maxConcurrentOperationCount = 2//并发队列
        
        queue.addOperation {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 1)
                print("1---\(Thread.current)")
            }
        }
        
        queue.addOperation {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 1)
                print("2---\(Thread.current)")
            }
        }
        
        queue.addOperation {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 1)
                print("3---\(Thread.current)")
            }
        }
        print("current---\(Thread.current)")
    }

最大并发操作数为1 输出结果：
current---{number = 1, name = main}
1---{number = 4, name = (null)}
1---{number = 4, name = (null)}
1---{number = 4, name = (null)}
2---{number = 5, name = (null)}
2---{number = 5, name = (null)}
2---{number = 5, name = (null)}
3---{number = 5, name = (null)}
3---{number = 5, name = (null)}
3---{number = 5, name = (null)}

最大并发操作数为2 输出结果：
current---{number = 1, name = main}
2---{number = 5, name = (null)}
1---{number = 4, name = (null)}
1---{number = 4, name = (null)}
2---{number = 5, name = (null)}
2---{number = 5, name = (null)}
1---{number = 4, name = (null)}
3---{number = 4, name = (null)}
3---{number = 4, name = (null)}
3---{number = 4, name = (null)}

从输出可以看出，当maxConcurrentOperationCount为1时，操作是按顺序串行执行的，操作执行完一个才执行下一个。当maxConcurrentOperationCount大于1时，操作是并发执行的，同时有两个操作执行。而开启线程的数量是同系统决定的，不需要自己管理

6.NSOperation 操作依赖

NSOperationQueue可以通过addDependency方法来控制操作的执行顺序。关于依赖相关属性及方法有三个：

open func addDependency(_ op: Operation)// 添加依赖，使当前操作依赖于操作 op 的完成

open func removeDependency(_ op: Operation)//移除依赖，取消当前操作对操作 op 的依赖

open var dependencies: [Operation] { get }//在当前操作开始执行之前完成执行的所有操作对象数组

    /**
    * 操作依赖
    * 使用方法：addDependency:
    */
    func addDependency(){
        // 1.创建队列
        let queue = OperationQueue.init()
        
        // 2.创建操作
        let op = BlockOperation.init {
            for _ in 0...2{
                print("0---\(Thread.current)")
            }
        }
        
        let op1 = BlockOperation.init {
            for _ in 0...2{
                Thread.sleep(forTimeInterval: 1)
                print("1---\(Thread.current)")
            }
        }
        
        // 3.添加依赖
        op.addDependency(op1)// 让op 依赖于 op1，则先执行op1，在执行op，右先左后
        
        // 4.添加操作到队列中
        queue.addOperation(op)
        queue.addOperation(op1)
        print("current---\(Thread.current)")
    }

输出：
current---{number = 1, name = main}
1---{number = 5, name = (null)}
1---{number = 5, name = (null)}
1---{number = 5, name = (null)}
0---{number = 6, name = (null)}
0---{number = 6, name = (null)}
0---{number = 6, name = (null)}

7.NSOperation 优先级

NSOperation 提供了queuePriority（优先级）属性

public enum QueuePriority : Int {

    case veryLow

    case low

    case normal

    case high

    case veryHigh
}

    /**
    * 优先级使用
    * 使用属性：queuePriority
    */
    func queuePriority(){
        // 1.创建队列
        let queue = OperationQueue.init()
        
        // 2.创建操作
        let op = BlockOperation.init {
            print("veryLow---\(Thread.current)")
        }
        
        let op1 = BlockOperation.init {
            print("low---\(Thread.current)")
        }
        
        let op2 = BlockOperation.init {
            print("normal---\(Thread.current)")
        }
        
        let op3 = BlockOperation.init {
            print("high---\(Thread.current)")
        }
        
        let op4 = BlockOperation.init {
            print("veryHigh---\(Thread.current)")
        }
        
        let op5 = BlockOperation.init {
            print("normal5---\(Thread.current)")
        }
        
        op.queuePriority = .veryLow
        op1.queuePriority = .low
        op2.queuePriority = .normal
        op5.queuePriority = .normal
        op3.queuePriority = .high
        op4.queuePriority = .veryHigh
        
        queue.addOperation(op)
        queue.addOperation(op1)
        queue.addOperation(op2)
        queue.addOperation(op3)
        queue.addOperation(op4)
        queue.addOperation(op5)
        
    }

输出：
veryLow---{number = 4, name = (null)}
low---{number = 5, name = (null)}
normal---{number = 3, name = (null)}
high---{number = 3, name = (null)}
normal5---{number = 3, name = (null)}
veryHigh---{number = 4, name = (null)}

这里可能会有个误区，认为优先级就可以决定操作的执行顺序。以上输出可以看到并不能，这些优先级都是相对的，并不是说必须按高到低的优先级来执行。这里面并没有一个特别严格顺序。只是在分配资源上有倾向性。如果队列需要有严格的执行顺序，还是要添加依赖关系的

8. NSOperation、NSOperationQueue 线程间的通信

    /**
    * 线程间通信
    */
    func communication(){
        // 1.创建队列
        let queue = OperationQueue.init()
        
        queue.addOperation {
            sleep(1)                                //耗时操作 如：下载文件
            print("1---\(Thread.current)")
            OperationQueue.main.addOperation {
                print("更新操作---\(Thread.current)")
            }
        }
    }

输出：
1---{number = 5, name = (null)}
更新操作---{number = 1, name = main}

9. NSOperation、NSOperationQueue 线程同步和线程安全

  • 线程安全：若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全
  • 线程同步：可理解为线程 A 和 线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作

下面模拟一下火车票的售卖方式：

    /**
    * 非线程安全
    * 初始化火车票数量、卖票窗口、并开始卖票
    */
    func initTicketStatusNoSave(){
        print("mainThread---\(Thread.current)")
        
        let queue = OperationQueue.init()
        
        queue.addOperation {
            self.saleTickeSafe()//开始卖票
        }
        
        queue.addOperation {
            self.saleTickeSafe()//开始卖票
        }
    }
    /**
    * 售卖火车票(非线程安全)
    */
    func saleTickeNoSafe(){
        while true {
            if self.num > 0{
                self.num = self.num - 1
                print("剩余票数：\(self.num), 窗口：\(Thread.current)")
                Thread.sleep(forTimeInterval: 0.2)
            }else{
                print("所有火车票已卖完")
                break
            }
        }
    }

输出：
mainThread---{number = 1, name = main}
剩余票数：49, 窗口：{number = 3, name = (null)}
剩余票数：48, 窗口：{number = 6, name = (null)}
剩余票数：47, 窗口：{number = 6, name = (null)}
剩余票数：46, 窗口：{number = 3, name = (null)}
剩余票数：44, 窗口：{number = 3, name = (null)}
剩余票数：44, 窗口：{number = 6, name = (null)}
剩余票数：43, 窗口：{number = 3, name = (null)}
剩余票数：43, 窗口：{number = 6, name = (null)}
剩余票数：42, 窗口：{number = 3, name = (null)}
......中间省略一部分
所有火车票已卖完
剩余票数：0, 窗口：{number = 6, name = (null)}
所有火车票已卖完

输出可以看数据是错乱的，这是非线程安全
线程安全解决方案：可以给线程加锁，在一个线程执行该操作的时候，不允许其他线程进行操作。iOS 实现线程加锁有很多种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/ge等等各种方式。iOS 线程同步方案学习总结，这里我们使用 NSLock 对象来解决线程同步问题。

    /**
    * 使用 NSLock 保证线程安全
    * 初始化火车票数量、卖票窗口、并开始卖票
    */
    func initTicketStatusSave(){
        print("mainThread---\(Thread.current)")
        
        let queue = OperationQueue.init()
        
        queue.addOperation {
            self.saleTickeSafe()//开始卖票
        }
        
        queue.addOperation {
            self.saleTickeSafe()//开始卖票
        }
    }
    /**
    * 售卖火车票
    */
    func saleTickeSafe(){
        while true {
            lock.lock()
            if self.num > 0{
                self.num = self.num - 1
                print("剩余票数：\(self.num), 窗口：\(Thread.current)")
                Thread.sleep(forTimeInterval: 0.2)
            }else{
                print("所有火车票已卖完")
                break
            }
            lock.unlock()
        }
    }

输出：
mainThread---{number = 1, name = main}
剩余票数：49, 窗口：{number = 4, name = (null)}
剩余票数：48, 窗口：{number = 4, name = (null)}
剩余票数：47, 窗口：{number = 4, name = (null)}
剩余票数：46, 窗口：{number = 4, name = (null)}
剩余票数：45, 窗口：{number = 4, name = (null)}
剩余票数：44, 窗口：{number = 4, name = (null)}
剩余票数：43, 窗口：{number = 4, name = (null)}
......中间省略一部分
剩余票数：1, 窗口：{number = 3, name = (null)}
剩余票数：0, 窗口：{number = 3, name = (null)}
所有火车票已卖完

输出可以看出，在保证线程安全的情况下，数据没有错乱。

10. NSOperation、NSOperationQueue 常用属性和方法归纳

10.1 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;添加依赖，使当前操作依赖于操作 op 的完成。
    • (void)removeDependency:(NSOperation *)op;移除依赖，取消当前操作对操作 op 的依赖。
    • @property (readonly, copy) NSArray *dependencies;在当前操作开始执行之前完成执行的所有操作对象数组。
10.2 NSOperationQueue 常用属性和方法
  1. 取消/暂停/恢复操作：
    • (void)cancelAllOperations; 可以取消队列的所有操作。
    • (BOOL)isSuspended; 判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态。
    • (void)setSuspended:(BOOL)b; 可设置操作的暂停和恢复，YES 代表暂停队列，NO 代表恢复队列。
  2. 操作同步：
    • (void)waitUntilAllOperationsAreFinished; 阻塞当前线程，直到队列中的操作全部执行完毕。
  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; 获取主队列。

注意：
1.这里的暂停和取消（包括操作的取消和队列的取消）并不代表可以将当前的操作立即取消，而是当当前的操作执行完毕之后不再执行新的操作。
2.暂停和取消的区别在于：暂停操作之后还可以恢复操作，继续向下执行；而取消操作之后，所有的操作就清空了，无法再接着执行剩下的操作。

参考资料：
iOS多线程：『NSOperation、NSOperationQueue』详尽总结
细说 NSoperation

相关：
iOS GCD学习总结(一)
iOS GCD学习总结(二)
iOS 线程同步方案学习总结

你可能感兴趣的:(NSOperation和NSOperationQueue学习总结)

  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 芦花鞋一四 许叶晗
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 绘本讲师训练营【24期】8/21阅读原创《独生小孩》 1784e22615e0
    24016-孟娟《独生小孩》图片发自App今天我想分享一个蛮特别的绘本，讲的是一个特殊的群体，我也是属于这个群体，80后的独生小孩。这是一本中国绘本，作者郭婧，也是一个80厚。全书一百多页，均为铅笔绘制，虽然为黑白色调，但并不显得沉闷。全书没有文字，犹如“默片”，但并不影响读者对该作品的理解，反而显得神秘，梦幻，給读者留下想象的空间。作者在前蝴蝶页这样写到：“我更希望父母和孩子一起分享这本书，使他
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • 本周第二次约练 2cfbdfe28a51
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
  • 放下是一段成长的修行 小莳玥
    人来到这个世界上，只有两件事：生和死。一件事已经做完了，另一件你还急什么呢?是人，都有七情六欲。是心，都有喜怒哀乐，这些再正常不过了。别总抱怨自己活得累，过得辛苦。永远记住：舒坦是留给死人的。苦，才是生活；累，才是工作；变，才是命运；忍，才是历练；容，才是智慧；静，才是修养；舍，才会得到；做，才会拥有。人生，活得太清楚，才是最大的不明白。有些事，看得很清，却说不清；有些人，了解很深，却猜不透；有些
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • 网易严选官方旗舰店，优质商品，卓越服务 高省_飞智666600
    网易严选官方旗舰店是网易旗下的一家电商平台，以提供优质商品和卓越服务而闻名。作为一名SEO优化师，我将为您详细介绍网易严选官方旗舰店，并重点强调其特点和优势。大家好！我是高省APP最大团队&联合创始人飞智导师。相较于其他返利app，高省APP的佣金更高，模式更好，最重要的是，终端用户不会流失！高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • VMware Workstation 11 或者 VMware Player 7安装MAC OS X 10.10 Yosemite iwindyforest vmwaremac os10.10workstationplayer
    最近尝试了下VMware下安装MacOS 系统， 安装过程中发现网上可供参考的文章都是VMware Workstation 10以下， MacOS X 10.9以下的文章， 只能提供大概的思路， 但是实际安装起来由于版本问题， 走了不少弯路， 所以我尝试写以下总结， 希望能给有兴趣安装OSX的人提供一点帮助。     写在前面的话： 其实安装好后发现， 由于我的th
  • 关于《基于模型驱动的B/S在线开发平台》源代码开源的疑虑？ deathwknight JavaScriptjava框架
    本人从学习Java开发到现在已有10年整，从一个要自学 java买成javascript的小菜鸟，成长为只会java和javascript语言的老菜鸟（个人邮箱：[email protected]） 一路走来，跌跌撞撞。用自己的三年多业余时间，瞎搞一个小东西（基于模型驱动的B/S在线开发平台，非MVC框架、非代码生成）。希望与大家一起分享，同时有许些疑虑，希望有人可以交流下 平台
  • 如何把maven项目转成web项目 Kai_Ge mavenMyEclipse
    创建Web工程，使用eclipse ee创建maven web工程 1.右键项目,选择Project Facets,点击Convert to faceted from 2.更改Dynamic Web Module的Version为2.5.(3.0为Java7的,Tomcat6不支持). 如果提示错误,可能需要在Java Compiler设置Compiler compl
  • 主管？？？ Array_06 工作
    转载：http://www.blogjava.net/fastzch/archive/2010/11/25/339054.html 很久以前跟同事参加的培训，同事整理得很详细，必须得转！ 前段时间，公司有组织中高阶主管及其培养干部进行了为期三天的管理训练培训。三天的课程下来，虽然内容较多，因对老师三天来的课程内容深有感触，故借着整理学习心得的机会，将三天来的培训课程做了一个
  • python内置函数大全 2002wmj python
    最近一直在看python的document，打算在基础方面重点看一下python的keyword、Build-in Function、Build-in Constants、Build-in Types、Build-in Exception这四个方面，其实在看的时候发现整个《The Python Standard Library》章节都是很不错的，其中描述了很多不错的主题。先把Build-in Fu
  • JSP页面通过JQUERY合并行 357029540 JavaScriptjquery
    在写程序的过程中我们难免会遇到在页面上合并单元行的情况，如图所示 如果对于会的同学可能很简单，但是对没有思路的同学来说还是比较麻烦的，提供一下用JQUERY实现的参考代码 function mergeCell(){         var trs = $("#table tr"); &nb
  • Java基础 冰天百华 java基础
    学习函数式编程 package base; import java.text.DecimalFormat; public class Main { public static void main(String[] args) { // Integer a = 4; // Double aa = (double)a / 100000; // Decimal
  • unix时间戳相互转换 adminjun 转换unix时间戳
    如何在不同编程语言中获取现在的Unix时间戳(Unix timestamp)？ Java time JavaScript Math.round(new Date().getTime()/1000) getTime()返回数值的单位是毫秒 Microsoft .NET / C# epoch = (DateTime.Now.ToUniversalTime().Ticks - 62135
  • 作为一个合格程序员该做的事 aijuans 程序员
    作为一个合格程序员每天该做的事 1、总结自己一天任务的完成情况 最好的方式是写工作日志，把自己今天完成了什么事情，遇见了什么问题都记录下来，日后翻看好处多多 2、考虑自己明天应该做的主要工作 把明天要做的事情列出来，并按照优先级排列，第二天应该把自己效率最高的时间分配给最重要的工作 3、考虑自己一天工作中失误的地方，并想出避免下一次再犯的方法 出错不要紧，最重
  • 由html5视频播放引发的总结 ayaoxinchao html5视频video
    前言   项目中存在视频播放的功能，前期设计是以flash播放器播放视频的。但是现在由于需要兼容苹果的设备，必须采用html5的方式来播放视频。我就出于兴趣对html5播放视频做了简单的了解，不了解不知道，水真是很深。本文所记录的知识一些浅尝辄止的知识，说起来很惭愧。   视频结构   本该直接介绍html5的<video>的，但鉴于本人对视频
  • 解决httpclient访问自签名https报javax.net.ssl.SSLHandshakeException: sun.security.validat bewithme httpclient
         如果你构建了一个https协议的站点，而此站点的安全证书并不是合法的第三方证书颁发机构所签发，那么你用httpclient去访问此站点会报如下错误   javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path bu
  • Jedis连接池的入门级使用 bijian1013 redisredis数据库jedis
    Jedis连接池操作步骤如下：         a.获取Jedis实例需要从JedisPool中获取；         b.用完Jedis实例需要返还给JedisPool；         c.如果Jedis在使用过程中出错，则也需要还给JedisPool； packag
  • 变与不变 bingyingao 不变变亲情永恒
    变与不变    周末骑车转到了五年前租住的小区，曾经最爱吃的西北面馆、江西水饺、手工拉面早已不在，    各种店铺都换了好几茬，这些是变的。    三年前还很流行的一款手机在今天看起来已经落后的不像样子。    三年前还运行的好好的一家公司，今天也已经不复存在。    一座座高楼拔地而起，
  • 【Scala十】Scala核心四：集合框架之List bit1129 scala
    Spark的RDD作为一个分布式不可变的数据集合，它提供的转换操作，很多是借鉴于Scala的集合框架提供的一些函数，因此，有必要对Scala的集合进行详细的了解   1. 泛型集合都是协变的，对于List而言，如果B是A的子类，那么List[B]也是List[A]的子类，即可以把List[B]的实例赋值给List[A]变量   2. 给变量赋值(注意val关键字，a，b
  • Nested Functions in C bookjovi cclosure
      Nested Functions 又称closure，属于functional language中的概念，一直以为C中是不支持closure的，现在看来我错了，不过C标准中是不支持的，而GCC支持。   既然GCC支持了closure，那么 lexical scoping自然也支持了，同时在C中label也是可以在nested functions中自由跳转的
  • Java-Collections Framework学习与总结-WeakHashMap BrokenDreams Collections
            总结这个类之前，首先看一下Java引用的相关知识。Java的引用分为四种：强引用、软引用、弱引用和虚引用。         强引用：就是常见的代码中的引用，如Object o = new Object();存在强引用的对象不会被垃圾收集
  • 读《研磨设计模式》-代码笔记-解释器模式-Interpret bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 解释器（Interpreter）模式的意图是可以按照自己定义的组合规则集合来组合可执行对象 * * 代码示例实现XML里面1.读取单个元素的值 2.读取单个属性的值 * 多
  • After Effects操作&快捷键 cherishLC After Effects
    1、快捷键官方文档 中文版：https://helpx.adobe.com/cn/after-effects/using/keyboard-shortcuts-reference.html 英文版：https://helpx.adobe.com/after-effects/using/keyboard-shortcuts-reference.html 2、常用快捷键
  • Maven 常用命令 crabdave maven
    Maven 常用命令   mvn archetype:generate mvn install mvn clean mvn clean complie mvn clean test mvn clean install mvn clean package mvn test mvn package mvn site   mvn dependency:res
  • shell bad substitution daizj shell脚本
    #!/bin/sh /data/script/common/run_cmd.exp 192.168.13.168 "impala-shell -islave4 -q 'insert OVERWRITE table imeis.${tableName} select ${selectFields}, ds, fnv_hash(concat(cast(ds as string), im
  • Java SE 第二讲（原生数据类型 Primitive Data Type） dcj3sjt126com java
    Java SE  第二讲： 1.   Windows: notepad, editplus, ultraedit, gvim Linux: vi, vim, gedit 2.   Java 中的数据类型分为两大类： 1）原生数据类型  （Primitive Data Type） 2）引用类型（对象类型）  （R
  • CGridView中实现批量删除 dcj3sjt126com PHPyii
    1，CGridView中的columns添加 array( 'selectableRows' => 2, 'footer' => '<button type="button" onclick="GetCheckbox();" style=&
  • Java中泛型的各种使用 dyy_gusi java泛型
    Java中的泛型的使用：1.普通的泛型使用 在使用类的时候后面的<>中的类型就是我们确定的类型。 public class MyClass1<T> {//此处定义的泛型是T private T var; public T getVar() { return var; } public void setVa
  • Web开发技术十年发展历程 gcq511120594 Web浏览器数据挖掘
    回顾web开发技术这十年发展历程： Ajax 03年的时候我上六年级，那时候网吧刚在小县城的角落萌生。传奇，大话西游第一代网游一时风靡。我抱着试一试的心态给了网吧老板两块钱想申请个号玩玩，然后接下来的一个小时我一直在，注，册，账，号。 彼时网吧用的512k的带宽，注册的时候，填了一堆信息，提交，页面跳转，嘣，”您填写的信息有误，请重填”。然后跳转回注册页面，以此循环。我现在时常想，如果当时a
  • openSession()与getCurrentSession()区别： hetongfei javaDAOHibernate
    来自 http://blog.csdn.net/dy511/article/details/6166134 1.getCurrentSession创建的session会和绑定到当前线程,而openSession不会。 2. getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而openSession必须手动关闭。 这里getCurrentSession本地事务(本地
  • 第一章 安装Nginx+Lua开发环境 jinnianshilongnian nginxluaopenresty
    首先我们选择使用OpenResty，其是由Nginx核心加很多第三方模块组成，其最大的亮点是默认集成了Lua开发环境，使得Nginx可以作为一个Web Server使用。借助于Nginx的事件驱动模型和非阻塞IO，可以实现高性能的Web应用程序。而且OpenResty提供了大量组件如Mysql、Redis、Memcached等等，使在Nginx上开发Web应用更方便更简单。目前在京东如实时价格、秒
  • HSQLDB In-Process方式访问内存数据库 liyonghui160com
        HSQLDB一大特色就是能够在内存中建立数据库，当然它也能将这些内存数据库保存到文件中以便实现真正的持久化。   先睹为快！   下面是一个In-Process方式访问内存数据库的代码示例：     下面代码需要引入hsqldb.jar包 （hsqldb-2.2.8）   import java.s
  • Java线程的5个使用技巧 pda158 java数据结构
    Java线程有哪些不太为人所知的技巧与用法？ 　　萝卜白菜各有所爱。像我就喜欢Java。学无止境，这也是我喜欢它的一个原因。日常 工作中你所用到的工具，通常都有些你从来没有了解过的东西，比方说某个方法或者是一些有趣的用法。比如说线程。没错，就是线程。或者确切说是Thread这个类。当我们在构建高可扩展性系统的时候，通常会面临各种各样的并发编程的问题，不过我们现在所要讲的可能会略有不同。
  • 开发资源大整合：编程语言篇——JavaScript（1） shoothao JavaScript
    概述：本系列的资源整合来自于github中各个领域的大牛，来收藏你感兴趣的东西吧。     程序包管理器   管理javascript库并提供对这些库的快速使用与打包的服务。 Bower - 用于web的程序包管理。 component - 用于客户端的程序包管理，构建更好的web应用程序。 spm - 全新的静态的文件包管
  • 避免使用终结函数 vahoa.ma javajvmC++
    终结函数（finalizer）通常是不可预测的，常常也是很危险的，一般情况下不是必要的。使用终结函数会导致不稳定的行为、更差的性能，以及带来移植性问题。不要把终结函数当做C++中的析构函数（destructors）的对应物。       我自己总结了一下这一条的综合性结论是这样的： 1）在涉及使用资源，使用完毕后要释放资源的情形下，首先要用一个显示的方
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他