Dispatch Timer

AtomicStorage.swift

//
//  main.swift
//  runLoop
//
//  Created by menangen on 27.12.2021.
//

import Foundation

extension Thread {
    var number: String {
        "\(value(forKeyPath: "private.seqNum")!)"
    }
}

actor AtomicStorage {

    private var storage: [Int: String]
    
    init() {
        print("init actor thread: \(Thread.current.number)")
        self.storage = [:]
    }
        
    func get(_ key: Int) -> String? {
        storage[key]
    }
    
    func set(_ key: Int, value: String) {
        storage[key] = value + ", actor thread: \(Thread.current.number)"
    }

    var allValues: [Int: String] {
        print("allValues actor thread: \(Thread.current.number)")
        return storage
    }
}

Task {
    
    print("Hello, Task!")
    
    await Task.sleep(1_000_000_000)
    
    print("Task thread:", Thread.current.number)
    
    
    let storage = AtomicStorage()
    await withTaskGroup(of: Void.self) { group in
        for i in 0..<10 {
            group.addTask {
                await storage.set(i, value: "caller thread: \(Thread.current.number)")
            }
        }
    }
    for (k, v) in await storage.allValues {
        print(k, v)
    }
}

sleep(2)

main.swift

//
//  main.swift
//  runLoop
//
//  Created by menangen on 09.12.2021.
//

import Foundation
import Dispatch

let q = DispatchQueue(label: "Timer")

let delay : DispatchTime = .now() + .seconds(1)
let timeoutTimer = DispatchSource.makeTimerSource(queue: q)

timeoutTimer.setEventHandler {
    print("setEventHandler", Thread.current)
    usleep(500000)
}


timeoutTimer.schedule(deadline: delay, repeating: 0.2, leeway: .microseconds(50))

print("timeoutTimer.resume", timeoutTimer.resume())
sleep(3)
timeoutTimer.cancel()

NSThread-DispatchGroup.swift

import Foundation

let group = DispatchGroup()

class WriterThread: Thread {
    var counter: UInt32 = 0
    var isRunning = true
    
    override func cancel() { isRunning = false }
    override func main() {
        
        repeat {
            print("Hello, Thread!", Thread.current)
            
            Thread.sleep(forTimeInterval: 1)
            
            counter += 1
            
            if counter > 5 { self.cancel() }
        } while isRunning
        
        print("Leaving")
        group.leave()
    }
}

group.enter()

let a = WriterThread()
a.start()

group.wait()

OperationQueue.swift

import Foundation

class WriterThread: Operation {
    var counter: UInt32 = 0
    
    override func main() {
        var isRunning = true
        
        repeat {
            print("Hello, Thread!", Thread.current)
            
            Thread.sleep(forTimeInterval: 1)
            
            counter += 1
            
            if counter > 5 { isRunning = false }
        } while isRunning
    }
}

let opQ = OperationQueue()
opQ.maxConcurrentOperationCount = 1

opQ.addOperations([WriterThread(), WriterThread()], waitUntilFinished: true)