Queue.Background

// Asynchronously
Queue.Utility.async {
    ...
}
// Or asynchronously using the operator shortcut
Queue.Utility <<< {
    ...
}

// Synchronously
Queue.Utility.sync { // Eki will prevent deadlock if you submit a sync on the current queue
    ...
}

Queue.Utility <<< {
    // Block 1
} <<< {
    // Block 2
}
// Or by submitting an array of blocks:
let blocks = [{
    // Block 1
}, {
    // Block 2
}]
Queue.Utility.async(blocks)

let queue = Queue(name:"QueueName", kind:.Concurrent)
queue.async{
    ...
}

let queue:Queue = Queue(name:"QueueName", type:.Concurrent)
...
queue |<| { // Or barrierAsync { }
    // This block will be executed on the queue only after all previous submitted blocks have been executed
} <<< {
    // This block will be executed only after the previous barrier block have completed
}

Queue.Background.after(2) {
    // Do some stuff on Background after 2 seconds
}

Queue.Background.iterate(4) { i in
    // Do some stuff on Background 4 times
}

Queue.current // Get current queue
Queue.Background.isCurrent // Check if background is current queue

let t = Task(queue:.Utility) {
    ...
}
// Or
let t = Queue.Utility + {
    ...
}

t.async() // Dispatch asynchronously

group.async(t) // Dispatch on a group

let tasks:[Task] = ...
g.async(tasks) // Tasks dispatched on a group.

t.chain {
    // Executed after t on same queue
}.chain(Task(queue:.Main) {
    // Executed after previous block on the main queue
})
t.async()

// Or chain directly after async and use the operator shortcut
t.async() <> {  
    // Executed after t on same queue
} <> Queue.Main + {
    // Executed after previous block on the main queue
}

let g = Group(queue:.Utility) // By default the group queue is Background

g.async {
    // Block dispatched on the group's queue.
} <<< {
    // Block dispatched on the group's queue using the operator.
} <<< Task(queue:.Main) {
    // Block dispatched on the Main queue (see Task).
}

let blocks:[()-> Void] = ...
g.async(blocks) // Blocks dispatched on the group's queue.

g.notify {
    // Block executed on the group queue when blocks previously dispatched on the group have been executed.
}
g.notify(Queue.Main + {
    // Block executed on the Main queue when blocks previously dispatched on the group have been executed.
})

g.wait() // Wait on the current process the group's blocks execution.

let once = OnceDispatcher() // Store it somewhere
...
once {
    // Executed only one time
}

let timer = Timer.scheduleWithInterval(2, onQueue: .Background) {
   // Do some stuff on Background after 2 seconds
}
// Equivalent to:
let timer = Timer(queue: .Background, interval: 2)
timer.handler {
  // Do some stuff on Background after 2 seconds
}
timer.start() // Timers are paused at Initialization

timer.pause()
timer.start()
timer.stop()

let date: NSDate = ...
let timer = Timer(queue: .Background, date: date)
timer.repeatInterval = 4
timer.tolerance =  1 // Add some tolerance
timer.handler {
  // Do some stuff on Background on specified date and after every 4 seconds approximately
}
timer.start()

let sem = Semaphore(.Binary)
let customSem = Semaphore(resource:5)

sem.wait()
  // Do some stuff when a resource is available
sem.signal()

// Or
sem--
  ...
sem++

sem.perform {
    // Do some stuff when a resource is available
}

// Or
sem <<< {
    ...
}

let m = Mutex()
...
m.sync {
    // Do some stuff when a mutext is available
}

// Or
m <<< {
  ...
}

let myobj = MyObject()
let l = LockedObject(myobj)
...
l.access { obj in
    // Only one process at a time will access the locked object
}

// Or
l <<< { obj in
  ...
}