         qos: DispatchQoS = .default,
         flags: DispatchWorkItemFlags = .inheritQoS,
         execute work: @escaping @convention(block) () -> Void) {
-        /// Serial queue acting as gate keeper, to ensure only one thread is blocked. Otherwise all threads waiting in jobQueue are blocked.
+        // Serial queue acting as gate keeper, to ensure only one thread is blocked. Otherwise all threads waiting in jobQueue are blocked.
         gateKeeperQueue.async { [weak self] in
             guard let `self` = self else {return}
             // Wait out of ThreadPool, to avoid overload system shared ThreadPool

                autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency = .inherit,
                target: DispatchQueue? = nil,
                maxConcurrentCount: Int) {
        /// Max concurrent block count
        self.maxConcurrentCount = maxConcurrentCount
        /// Initialize semaphore
        semaphore = DispatchSemaphore(value: maxConcurrentCount)

        /// Serial queue acting as gate keeper, to ensure only one thread is blocked
        gateKeeperQueue = DispatchQueue(label: QueueLabel.gateKeeper.prefix(label),
                                        qos: qos,
                                        attributes: [],
                                        autoreleaseFrequency: autoreleaseFrequency,
                                        target: target)

        /// Actual concurrent working queue
        jobQueue = DispatchQueue(label: QueueLabel.job.prefix(label),
                                 qos: qos,
                                 attributes: attributes,


    /// Asynchronization: DispatchWorkItem
    public func async(execute workItem: DispatchWorkItem) {
        // Serial queue acting as gate keeper, to ensure only one thread is blocked. Otherwise all threads waiting in jobQueue are blocked.
        gateKeeperQueue.async {[weak self] in
            guard let `self` = self else {return}
            self.semaphore.wait()
            
            // Actual concurrent working queue
            self.jobQueue.async {[weak self] in
                guard let `self` = self else {return}
                workItem.perform()
