How to prevent thread print to mix output in the console? - ios

Question

Say we have multiple threads issuing prints.
Typically when downloading stuffs as follows:
let url = self.url
print("loadPreview(\(source) for \(url)): ↝start loading \(self.url")
let task = session.downloadTask(with: url) {
(localUrl, response, error) in
print("loadPreview(\(source) for \(url)): == \(self.url")
}
Is there any way to make print atomic and prevent output as follows?
loadPreview(WSJ for www.wsj.co⟷TloadPreview(9loadPreview(appleins for appleinsid⟷n-messages): ↝start loading http://app⟷n-messages

Answer 1

A quick hack is just to use a NSLock around your print. For instance, you could define an atomic print function as:
private let printLock = NSLock()
func aprint(_ message: String){
printLock.lock()
defer { printLock.unlock() }
print(message)
}
and use it like the standard print function:
aprint(“This will print atomically!”)
You could also achieve a similar result using a serial DispatchQueue to serialize your print calls as well. For instance:
private let printQueue = DispatchQueue(label: "aprint", qos: .utility)
func aprint(_ message: String){
printQueue.async {
print(message)
}
}
This solution provides better performance mainly thanks to the async call. This ensures the calling thread will not block until the lock is acquired (and the corresponding print is completely performed). But, to be clear, this solution is also perfectly atomic as well.
(For the record, simply using DispatchQueue.main might behave weirdly if the calling code is also running on the main queue.)
I would recommend picking the second solution ;)

Answer 2

You can use DispatchIO to automatically serialise the output to either stdout or even a file in a non-blocking fashion. It's a bit more work and you may want to wrap the example below into a class:
import Foundation
// Open stdout with DispatchIO
let queue = DispatchQueue.global()
let fd = FileHandle.standardOutput.fileDescriptor
let writer = DispatchIO(type: .stream, fileDescriptor: fd, queue: queue) { (errno) in
if errno != 0 {
print("Cannot open stdout: \(errno)")
}
}
// Encode string
if let data = string.data(using: .utf8) {
data.withUnsafeBytes { (buffer) in
// Produce DispatchData with encoded string
let dispatchData = DispatchData(bytes: buffer)
// Print string to stdout
writer.write(offset: .zero, data: dispatchData, queue: queue) { (done, data, errno) in
if errno != 0 {
print("Write error: \(errno)")
}
}
}
}
// Close the DispatchIO when you don't need it anymore
writer.close()