La méthode Map de Swift Array est-elle implémentée simultanément?

Question

Vérifié le doc, mais ne parle pas de nombreux détails de l'implémentation. Vous vous demandez si pour un grand tableau, fonctionne-t-il de manière concurrente?

Answer 1

L'implémentation map de Array spécifiquement n'effectue pas de multithreading, mais rien ne dit que vous ne pouvez pas faire une implémentation simultanée. Voilà celui qui est généralisé à travailler avec tout Sequence:

import Dispatch 


class SharedSynchronizedArray<T> { 
    var array = [T]() 
    let operationQueue = DispatchQueue(label: "SharedSynchronizedArray") 

    func append(_ newElement: T) { 
     operationQueue.sync { 
      array.append(newElement) 
     } 
    } 
} 

public struct ConcurrentSequence<Base, Element>: Sequence 
    where Base: Sequence, Element == Base.Iterator.Element { 
    let base: Base 

    public func makeIterator() -> Base.Iterator { 
     return base.makeIterator() 
    } 

    public func map<T>(_ transform: @escaping (Element) -> T) -> [T] { 
     let group = DispatchGroup() 

     let resultsStorageQueue = DispatchQueue(label: "resultStorageQueue") 
     let results = SharedSynchronizedArray<T>() 

     let processingQueue = DispatchQueue(
      label: "processingQueue", 
      attributes: [.concurrent] 
     ) 

     for element in self { 
      group.enter() 
      print("Entered DispatchGroup for \(element)") 

      var result: T? 
      let workItem = DispatchWorkItem{ result = transform(element) } 

      processingQueue.async(execute: workItem) 

      resultsStorageQueue.async { 
       workItem.wait() 
       guard let unwrappedResult = result else { 
        fatalError("The work item was completed, but the result wasn't set!") 
       } 
       results.append(unwrappedResult) 


       group.leave() 
       print("Exited DispatchGroup for \(element)") 
      } 
     } 
     print("Started Waiting on DispatchGroup") 
     group.wait() 
     print("DispatchGroup done") 

     return results.array 
    } 


} 

public extension Sequence { 
    public var parallel: ConcurrentSequence<Self, Iterator.Element> { 
     return ConcurrentSequence(base: self) 
    } 
} 

print("Start") 

import Foundation 

let input = Array(0..<100) 
let output: [Int] = input.parallel.map { 
    let randomDuration = TimeInterval(Float(arc4random())/Float(UInt32.max)) 
    Thread.sleep(forTimeInterval: randomDuration) 
    print("Transforming \($0)") 
    return $0 * 2 
} 

print(output) 
// print(output.parallel.filter{ $0 % 3 == 0 }) 

print("Done")