让我概述一系列的备选方案。第一个方案只是解决你问题中的直接战术问题，后两个方案是进一步的改进，越来越复杂。
1.一旦操作开始，就不能调用addExecutionBlock。因此，只需创建一个新的Operation。
例如：

class ViewController: UIViewController {

    @IBOutlet weak var imageView1: UIImageView!

    weak var downloadOperation: Operation?    // make this weak

    var queue = OperationQueue()

    let imageURLs: [String] = ...

    @IBAction func didClickOnStart(_ sender: Any) {
        downloadOperation?.cancel()             // you might want to stop the previous one if you restart this

        let operation = BlockOperation {
            for (index, imageURL) in self.imageURLs.enumerate() {
                guard let cancelled = self.downloadOperation?.cancelled where !cancelled else  { return }

                let img1 = Downloader.downloadImageWithURL(imageURL)
                OperationQueue.main.addOperation {
                    self.imageView1.image = img1

                    print("index \(index)")
                }
            }
        }
        queue.addOperation(operation)

        downloadOperation = operation
    }

    @IBAction func didClickOnCancel(_ sender: Any) {
        downloadOperation?.cancel()
    }

}

1.值得注意的是，这将是不必要的缓慢，连续加载图像。您可以同时加载它们与如下：

class ViewController: UIViewController {

    @IBOutlet weak var imageView1: UIImageView!

    var queue: OperationQueue = {
        let _queue = OperationQueue()
        _queue.maxConcurrentOperationCount = 4
        return _queue
    }()

    let imageURLs: [String] = ...

    @IBAction func didClickOnStart(_ sender: Any) {
        queue.cancelAllOperations()

        let completionOperation = BlockOperation {
            print("all done")
        }

        for (index, imageURL) in self.imageURLs.enumerate() {
            let operation = BlockOperation {
                let img1 = Downloader.downloadImageWithURL(imageURL)
                OperationQueue.main.addOperation {
                    self.imageView1.image = img1

                    print("index \(index)")
                }
            }
            completionOperation.addDependency(operation)
            queue.addOperation(operation)
        }

        OperationQueue.main.addOperation(completionOperation)
    }

    @IBAction func didClickOnCancel(_ sender: Any) {
        queue.cancelAllOperations()
    }
}

1.即使这样也有问题。另一个问题是，当你“取消”时，它很可能会继续尝试下载当前正在下载的资源，因为你没有使用可取消的网络请求。
一种更好的方法是将下载（将通过URLSession执行） Package 在其自己的异步Operation子类中，并使其可取消，例如：

class ViewController: UIViewController {
    var queue: OperationQueue = {
        let _queue = OperationQueue()
        _queue.maxConcurrentOperationCount = 4
        return _queue
    }()

    let imageURLs: [URL] = ...

    @IBAction func didClickOnStart(_ sender: Any) {
        queue.cancelAllOperations()

        let completion = BlockOperation {
            print("done")
        }

        for url in imageURLs {
            let operation = ImageDownloadOperation(url: url) { result in
                switch result {
                case .failure(let error): 
                    print(url.lastPathComponent, error)

                case .success(let image): 
                    OperationQueue.main.addOperation {
                        self.imageView1.image = img1

                        print("index \(index)")
                    }
                }
            }
            completion.addDependency(operation)
            queue.addOperation(operation)
        }

        OperationQueue.main.addOperation(completion)
    }

    @IBAction func didClickOnCancel(_ sender: AnyObject) {
        queue.cancelAllOperations()
    }
}

在哪里

/// Simple image network operation

class ImageDownloadOperation: DataOperation {
    init(url: URL, session: URLSession = .shared, networkCompletionHandler: @escaping (Result<UIImage, Error>) -> Void) {
        super.init(url: url, session: session) { result in
            switch result {
            case .failure(let error):
                networkCompletionHandler(.failure(error))

            case .success(let data):
                guard let image = UIImage(data: data) else {
                    networkCompletionHandler(.failure(DownloadError.notImage))
                    return
                }

                networkCompletionHandler(.success(image))
            }
        }
    }
}

/// Simple network data operation
///
/// This can be subclassed for image-specific operations, JSON-specific operations, etc.

class DataOperation: AsynchronousOperation {
    var downloadTask: URLSessionTask?

    init(url: URL, session: URLSession = .shared, networkCompletionHandler: @escaping (Result<Data, Error>) -> Void) {
        super.init()

        downloadTask = session.dataTask(with: url) { data, response, error in
            defer { self.complete() }

            guard let data = data, let response = response as? HTTPURLResponse, error == nil else {
                networkCompletionHandler(.failure(error!))
                return
            }

            guard 200..<300 ~= response.statusCode else {
                networkCompletionHandler(.failure(DownloadError.invalidStatusCode(response)))
                return
            }

            networkCompletionHandler(.success(data))
        }
    }

    override func main() {
        downloadTask?.resume()
    }

    override func cancel() {
        super.cancel()

        downloadTask?.cancel()
    }
}

/// Asynchronous Operation base class
///
/// This class performs all of the necessary KVN of `isFinished` and
/// `isExecuting` for a concurrent `NSOperation` subclass. So, to developer
/// a concurrent NSOperation subclass, you instead subclass this class which:
///
/// - must override `main()` with the tasks that initiate the asynchronous task;
///
/// - must call `completeOperation()` function when the asynchronous task is done;
///
/// - optionally, periodically check `self.cancelled` status, performing any clean-up
///   necessary and then ensuring that `completeOperation()` is called; or
///   override `cancel` method, calling `super.cancel()` and then cleaning-up
///   and ensuring `completeOperation()` is called.

public class AsynchronousOperation: Operation {

    override public var isAsynchronous: Bool { return true }

    private let stateLock = NSLock()

    private var _executing: Bool = false
    override private(set) public var isExecuting: Bool {
        get {
            stateLock.withCriticalScope { _executing }
        }
        set {
            willChangeValue(forKey: "isExecuting")
            stateLock.withCriticalScope { _executing = newValue }
            didChangeValue(forKey: "isExecuting")
        }
    }

    private var _finished: Bool = false
    override private(set) public var isFinished: Bool {
        get {
            stateLock.withCriticalScope { _finished }
        }
        set {
            willChangeValue(forKey: "isFinished")
            stateLock.withCriticalScope { _finished = newValue }
            didChangeValue(forKey: "isFinished")
        }
    }

    /// Complete the operation
    ///
    /// This will result in the appropriate KVN of isFinished and isExecuting

    public func complete() {
        if isExecuting {
            isExecuting = false
        }

        if !isFinished {
            isFinished = true
        }
    }

    override public func start() {
        if isCancelled {
            isFinished = true
            return
        }

        isExecuting = true

        main()
    }

    override public func main() {
        fatalError("subclasses must override `main`")
    }
}

extension NSLock {

    /// Perform closure within lock.
    ///
    /// An extension to `NSLock` to simplify executing critical code.
    ///
    /// - parameter block: The closure to be performed.

    func withCriticalScope<T>(block: () throws -> T) rethrows -> T {
        lock()
        defer { unlock() }
        return try block()
    }
}