Comment exécuter un blocage sur une instance de thread?

Question

-je effectuer URLSession.shared.downloadTask demande, mais voudrait exécuter du code sur le même thread le downloadTask a été exécuté sur. Par exemple:

func sample() { 
    let thread = Thread.current 

    URLSession.shared.downloadTask(with: file) { 
     someFunc() //How to execute on thread variable? 
    }.resume() 
} 

Dans le gestionnaire d'achèvement downloadTask, il est en cours d'exécution sur un fil de fond. Cependant, je voudrais appeler someFunc() sur le même fil sample() a été appelé. Comment dois-je faire quelque chose comme Thread.current.async {...} je peux le faire:

func sample() { 
    let thread = Thread.current 

    URLSession.shared.downloadTask(with: file) { 
     thread.async { someFunc() } //Doesn't compile 
    }.resume() 
} 

Answer 1

Si vous voulez exécuter quelque chose sur un particulier Thread, vous n'utiliser cette API GCD, mais simplement:

perform(#selector(someMethod), on: thread, with: nil, waitUntilDone: false, modes: [RunLoopMode.commonModes.rawValue]) 

ce suppose bien sûr que vous avez créé un fil avec une boucle d'exécution, par exemple:

let thread = Thread(target: self, selector: #selector(threadEntryPoint), object: nil) 
thread.start() 

et

func threadEntryPoint() { 
    autoreleasepool { 
     Thread.current.name = "com.domain.app.background" 
     let runLoop = RunLoop.current 
     runLoop.add(NSMachPort(), forMode: .defaultRunLoopMode) 
     runLoop.run() 
    } 
} 

Pour plus d'informations, consultez le Threading Programming Guide.

Personnellement, je personnellement rester dans GCD si humainement possible, mais vous avez dit ailleurs que vous avez une exigence unique qui empêche cela.

Answer 2

Il n'y a rien comme Thread.current.async qui est la raison pour laquelle il ne compile pas.

Si vous souhaitez exécuter sample et someFunc sur le même fil que vous pouvez utiliser un Operation et un OperationQueue. Inconvénient de cette approche, vous ar bloquant un thread.

var myQueue:OperationQueue = { 
    let q = OperationQueue() 
    q.name = "downloadQueue" 
    // if you want to limit concurrent operation 
    q.maxConcurrentOperationCount = 5 
    return q 
}() 


class DowloadOperation :Operation { 

    enum State { 
     case Ready, Executing, Finished 
     // ... 
    } 

    var state = State.Ready { 
     willSet { 
      ... 
     } 
     didSet { 
      ... 
     } 
    }  

    override func start() { 
     if self.isCancelled { 
      state = .Finished 
     } else { 
      state = .Ready 
      main() 
     } 
    } 

    override var isFinished: Bool { 
     get { 
      return state == .Finished 
     } 
    } 

    override var isAsynchronous: Bool { 
     get { 
      return true 
     } 
    } 

    override var isExecuting: Bool { 
     get { 
      return state == .Executing 
     } 
    } 


    override func main() { 
     if self.isCancelled { 
      self.state == .Finished 
      return 
     } 

     state = .Executing 

     URLSession.shared.downloadTask(with: file) { 
      // ... 
      state = .Finished 
     } 

     }.resume() 
    } 
} 

func someFunc() { 
    ... 
} 

// sample and someFunc are executed on the same thread 
// you loose the advantage of the async download. 
func sample() { 
    downloadOp = DownloadOperation() 
    myQueue.addOperation(downloadOp) 
    downloadOp.waitUntilFinished() 
    someFunc() 
}