CPU使用率

cpu_usage.m

#import <mach/mach.h>
#import <sys/sysctl.h>

+ (double)cpuUsage {
    kern_return_t kr;
    task_info_data_t tinfo;
    mach_msg_type_number_t task_info_count;
    
    task_info_count = TASK_INFO_MAX;
    kr = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)tinfo, &task_info_count);
    if (kr != KERN_SUCCESS) {
        return -1;
    }
    
    task_basic_info_t      basic_info;
    thread_array_t         thread_list;
    mach_msg_type_number_t thread_count;
    
    thread_info_data_t     thinfo;
    mach_msg_type_number_t thread_info_count;
    
    thread_basic_info_t basic_info_th;
    uint32_t stat_thread = 0; // Mach threads
    
    basic_info = (task_basic_info_t)tinfo;
    
    // get threads in the task
    kr = task_threads(mach_task_self(), &thread_list, &thread_count);
    if (kr != KERN_SUCCESS) {
        return -1;
    }
    if (thread_count > 0)
        stat_thread += thread_count;
    
    long tot_sec = 0;
    long tot_usec = 0;
    double tot_cpu = 0;
    int j;
    
    for (j = 0; j < (int)thread_count; j++)
    {
        thread_info_count = THREAD_INFO_MAX;
        kr = thread_info(thread_list[j], THREAD_BASIC_INFO,
                         (thread_info_t)thinfo, &thread_info_count);
        if (kr != KERN_SUCCESS) {
            return -1;
        }
        
        basic_info_th = (thread_basic_info_t)thinfo;
        
        if (!(basic_info_th->flags & TH_FLAGS_IDLE)) {
            tot_sec = tot_sec + basic_info_th->user_time.seconds + basic_info_th->system_time.seconds;
            tot_usec = tot_usec + basic_info_th->user_time.microseconds + basic_info_th->system_time.microseconds;
            tot_cpu = tot_cpu + basic_info_th->cpu_usage / (double)TH_USAGE_SCALE * 100.0;
        }
        
    } // for each thread
    
    kr = vm_deallocate(mach_task_self(), (vm_offset_t)thread_list, thread_count * sizeof(thread_t));
    assert(kr == KERN_SUCCESS);
    
    return tot_cpu;
}

cpu_usage.swift

/// https://stackoverflow.com/a/44134397
func cpuUsage() -> Float {
    var kr: kern_return_t
    var tinfo = [integer_t]()
    var task_info_count: mach_msg_type_number_t

    task_info_count = mach_msg_type_number_t(TASK_INFO_MAX)

    kr = task_info(mach_task_self_, task_flavor_t(TASK_BASIC_INFO), &tinfo, &task_info_count)
    guard kr == KERN_SUCCESS else {
        return -1
    }

    var thread_list: thread_act_array_t? = UnsafeMutablePointer(mutating: [thread_act_t]())

    var thread_count: mach_msg_type_number_t = 0

    var thinfo: thread_info_t = UnsafeMutablePointer(mutating: [integer_t]())
    var thread_info_count: mach_msg_type_number_t

    kr = task_threads(mach_task_self_, &thread_list, &thread_count)

    guard kr == KERN_SUCCESS, let thlist = thread_list else {
        return -1
    }

    let THREAD_BASIC_INFO_COUNT: Int = MemoryLayout<thread_basic_info_data_t>.size / MemoryLayout<integer_t>.size
    var tot_cpu: Float = 0
    for index in 0 ..< Int(thread_count) {
        thread_info_count = mach_msg_type_number_t(THREAD_INFO_MAX)
        kr = thread_info(thlist[index], thread_flavor_t(THREAD_BASIC_INFO),
                         thinfo, &thread_info_count)
        guard kr == KERN_SUCCESS else {
            return -1
        }

        let th_basic_info = withUnsafePointer(to: &thinfo, {
            return $0.withMemoryRebound(to: thread_basic_info_t.self, capacity: THREAD_BASIC_INFO_COUNT, {
                return $0.pointee
            })
        }).pointee

        if th_basic_info.flags != TH_FLAGS_IDLE {
            tot_cpu = tot_cpu + (Float(th_basic_info.cpu_usage) / Float(TH_USAGE_SCALE)) * 100.0
        }
    } // for each thread

    return tot_cpu
}

在 swift 项目中用定时器中定时执行 cpu_usage.swift ，然后其他代码运行到字典的代码就会造成崩溃，暂时找不到原因，用 objc 代码混编完全没问题