Ios 检测使用主线程的时间百分比

我试图检测主线程繁忙的时间百分比，以便在用户使用应用程序时记录此指标。目前，我能找到的最接近的东西是

basic\u info

中的

user\u time

，有了答案的帮助，但我如何知道正在使用哪个线程以及它是否是主线程？那么，从这里我如何知道该时间占该会话的应用程序总运行时间的百分比是多少？

当应用程序处于前台时，主线程一直在使用。

---

因此，您可以在

ApplicationIDBecomeActive

中安排一个计时器，并在

applicationWillResignActive

中使其无效，并随时获取累计秒数。

因此，我使用以下方法设法解决了这一问题：

class MainThreadAnalyser {
    typealias SumTotal = (total: Double, elements: Double)

    private var threadPercentages = [Double]()

    private let timeIntervalSeconds: Double

    init(timeIntervalSeconds: Double) {
        self.timeIntervalSeconds = timeIntervalSeconds
        if #available(iOS 10.0, *) {
            self.startCPUMonitoring(timeIntervalSeconds: self.timeIntervalSeconds)
        }
    }

    func getAverageCpuUsage() -> Double? {
        let sumTotal = threadPercentages.reduce((total: 0, elements: 0)) { (sum, item) -> SumTotal in
            var result = sum
            if item > 0 {
                result.total += item
                result.elements += 1
            }

            return result
        }

        return sumTotal.elements > 0 ? sumTotal.total / sumTotal.elements : nil
    }

    @available(iOS 10.0, *)
    private func startCPUMonitoring(timeIntervalSeconds: Double) {
        Timer.scheduledTimer(withTimeInterval: timeIntervalSeconds, repeats: true) { [weak self] _ in
            guard let strongSelf = self else { return }
            if let cpuUsage = strongSelf.cpuUsage() {
                strongSelf.threadPercentages.append(cpuUsage)
            }
        }
    }

    private func cpuUsage() -> Double? {
        var kernReturn: kern_return_t
        var taskInfoCount: mach_msg_type_number_t

        taskInfoCount = mach_msg_type_number_t(TASK_INFO_MAX)
        var tinfo = [integer_t](repeating: 0, count: Int(taskInfoCount))

        kernReturn = task_info(mach_task_self_, task_flavor_t(TASK_BASIC_INFO), &tinfo, &taskInfoCount)
        if kernReturn != KERN_SUCCESS {
            return -1
        }

        var threadArray: thread_act_array_t? = UnsafeMutablePointer(mutating: [thread_act_t]())
        var threadCount: mach_msg_type_number_t = 0
        defer {
            if let threadArray = threadArray {
                vm_deallocate(mach_task_self_, vm_address_t(UnsafePointer(threadArray).pointee), vm_size_t(threadCount))
            }
        }

        kernReturn = task_threads(mach_task_self_, &threadArray, &threadCount)

        if kernReturn != KERN_SUCCESS {
            return -1
        }

        var totalCPU: Double?

        if let threadArray = threadArray {

            for index in 0 ..< Int(threadCount) {
                var threadInfoCount = mach_msg_type_number_t(THREAD_INFO_MAX)
                var thinfo = [integer_t](repeating: 0, count: Int(threadInfoCount))
                kernReturn = thread_info(threadArray[index], thread_flavor_t(THREAD_BASIC_INFO),
                                 &thinfo, &threadInfoCount)
                if kernReturn != KERN_SUCCESS {
                    return -1
                }

                if index == 0 {
                    let cpuUse = thinfo[4]
                    totalCPU = Double(cpuUse/10)

                }
            }
        }

        return totalCPU
    }
}

类主线程分析器{
typealias SumTotal=（总计：双精度，元素：双精度）
私有变量线程百分比=[Double]（）
私人出租时间间隔秒：双
初始化（时间间隔秒：双精度）{
self.timeIntervalSeconds=timeIntervalSeconds
如果可用（iOS 10.0，*）{
self.startCPUMonitoring（timeIntervalSeconds:self.timeIntervalSeconds）
}
}
func getAverageCpuUsage（）->Double{
让sumTotal=threadPercentages.reduce（（总数：0，元素：0））{（总和，项）->sumTotal in
var结果=总和
如果项目>0{
result.total+=项目
result.elements+=1
}
返回结果
}
返回sumTotal.elements>0？sumTotal.total/sumTotal.elements:nil
}
@可用（iOS 10.0，*）
专用函数StartCpumMonitoring（时间间隔秒：双精度）{
Timer.scheduledTimer（withTimeInterval:timeIntervalSeconds，repeats:true）{[weak self]\uuuin
guard let strongSelf=self-else{return}
如果让cpuUsage=strongSelf.cpuUsage（）{
strongSelf.threadPercentage.append（cpuUsage）
}
}
}
private func cpuUsage（）->Double{
var kernReturn:kern\u return\t
var任务信息计数：马赫数信息类型编号
任务信息计数=马赫数信息类型编号（任务信息最大值）
var tinfo=[integer_t]（重复：0，计数：Int（taskInfoCount））
kernReturn=task\u info（mach\u task\u self\u，task\u flavor\t（task\u BASIC\u info），&tinfo，&taskInfoCount）
如果KERN返回！=KERN_成功{
返回-1
}
var-threadArray:thread\u-act\u-array\u-t？=不可分配指针（变异：[thread\u-act\u-t]（））
变量线程数：马赫数消息类型编号t=0
推迟{
如果让threadArray=threadArray{
vm_解除分配（mach_task_self_、vm_address_t（UnsafePointer（threadArray.pointee）、vm_size_t（threadCount））
}
}
kernReturn=task\u线程（mach\u task\u self、&threadArray、&threadCount）
如果KERN返回！=KERN_成功{
返回-1
}
var totalCPU:双倍？
如果让threadArray=threadArray{
对于0..

目的是什么？你不能在AppDelegate中管理这个吗？