@ -2,6 +2,49 @@ import Foundation
import UIKit import UIKit
import Combine import Combine
// MARK: - 内 存 压 力 等 级 枚 举
enum MemoryPressureLevel : CaseIterable {
case normal
case moderate
case high
case critical
case extreme
var description : String {
switch self {
case . normal :
return " 正常 "
case . moderate :
return " 中等 "
case . high :
return " 高 "
case . critical :
return " 严重 "
case . extreme :
return " 极端 "
}
}
}
// MARK: - 系 统 内 存 使 用 结 构
struct SystemMemoryUsage {
let freeMB : Double
let activeMB : Double
let inactiveMB : Double
let wiredMB : Double
}
// MARK: - 详 细 内 存 信 息 结 构
struct DetailedMemoryInfo {
let residentMemoryMB : Double
let virtualMemoryMB : Double
let physicalMemoryMB : Double
let memoryPressure : MemoryPressureLevel
let availableMemoryMB : Double
let systemMemoryUsage : SystemMemoryUsage
let timestamp : Date
}
// MARK: - 内 存 监 控 器 // MARK: - 内 存 监 控 器
class MemoryMonitor : ObservableObject { class MemoryMonitor : ObservableObject {
static let shared = MemoryMonitor ( )
static let shared = MemoryMonitor ( )
@ -31,13 +74,26 @@ class MemoryMonitor: ObservableObject {
// MARK: - 内 存 使 用 监 控
// MARK: - 内 存 使 用 监 控
// / 获 取 当 前 内 存 使 用 情 况
// / 获 取 当 前 内 存 使 用 情 况 （ 更 准 确 的 方 法 ）
func getMemoryUsage ( ) -> String {
func getMemoryUsage ( ) -> String {
let usedMB = getMemoryUsageInMB ( )
return String ( format : " %.1f MB " , usedMB )
}
// / 获 取 内 存 使 用 量 （ M B ）
func getMemoryUsageInMB ( ) -> Double {
// 使 用 更 准 确 的 内 存 统 计 方 法
let stats = getAccurateMemoryStats ( )
return stats . residentMemoryMB
}
// / 获 取 准 确 的 内 存 统 计 信 息
private func getAccurateMemoryStats ( ) -> ( residentMemoryMB : Double , virtualMemoryMB : Double , physicalMemoryMB : Double ) {
var info = mach_task_basic_info ( )
var info = mach_task_basic_info ( )
var count = mach_msg_type_number_t ( MemoryLayout < mach_task_basic_info > . size ) / 4
var count = mach_msg_type_number_t ( MemoryLayout < mach_task_basic_info > . size / MemoryLayout < integer_t > . size )
let kerr : kern_return_t = withUnsafeMutablePointer ( to : & info ) {
let kerr : kern_return_t = withUnsafeMutablePointer ( to : & info ) {
$0 . withMemoryRebound ( to : integer_t . self , capacity : 1 ) {
$0 . withMemoryRebound ( to : integer_t . self , capacity : Int ( count ) ) {
task_info ( mach_task_self_ ,
task_info ( mach_task_self_ ,
task_flavor_t ( MACH_TASK_BASIC_INFO ) ,
task_flavor_t ( MACH_TASK_BASIC_INFO ) ,
$0 ,
$0 ,
@ -46,35 +102,116 @@ class MemoryMonitor: ObservableObject {
}
}
if kerr = = KERN_SUCCESS {
if kerr = = KERN_SUCCESS {
let usedMB = Double ( info . resident_size ) / 1024.0 / 1024.0
let residentMB = Double ( info . resident_size ) / 1024.0 / 1024.0
return String ( format : " %.1f MB " , usedMB )
let virtualMB = Double ( info . virtual_size ) / 1024.0 / 1024.0
let physicalMB = Double ( ProcessInfo . processInfo . physicalMemory ) / 1024.0 / 1024.0
return ( residentMB , virtualMB , physicalMB )
} else {
} else {
return " Unknown "
// 如 果 m a c h 调 用 失 败 ， 使 用 备 用 方 法
return getFallbackMemoryStats ( )
}
}
}
}
// / 备 用 内 存 统 计 方 法
private func getFallbackMemoryStats ( ) -> ( residentMemoryMB : Double , virtualMemoryMB : Double , physicalMemoryMB : Double ) {
// 使 用 N S P r o c e s s I n f o 作 为 备 用 方 案
let processInfo = ProcessInfo . processInfo
let physicalMemory = Double ( processInfo . physicalMemory ) / 1024.0 / 1024.0
// 估 算 内 存 使 用 （ 基 于 系 统 总 内 存 的 百 分 比 ）
let estimatedUsage = physicalMemory * 0.1 // 假 设 使 用 1 0 % ， 这 是 一 个 保 守 估 计
return ( estimatedUsage , estimatedUsage * 2 , physicalMemory )
}
// / 获 取 内 存 使 用 详 情
// / 获 取 内 存 使 用 详 情
func getMemoryUsageDetails ( ) -> ( usedMB : Double , totalMB : Double , percentage : Double ) {
func getMemoryUsageDetails ( ) -> ( usedMB : Double , totalMB : Double , percentage : Double ) {
var info = mach_task_basic_info ( )
let stats = getAccurateMemoryStats ( )
var count = mach_msg_type_number_t ( MemoryLayout < mach_task_basic_info > . size ) / 4
let usedMB = stats . residentMemoryMB
let totalMB = stats . physicalMemoryMB
let percentage = totalMB > 0 ? ( usedMB / totalMB ) * 100.0 : 0.0
let kerr : kern_return_t = withUnsafeMutablePointer ( to : & info ) {
return ( usedMB , totalMB , percentage )
$0 . withMemoryRebound ( to : integer_t . self , capacity : 1 ) {
}
task_info ( mach_task_self_ ,
task_flavor_t ( MACH_TASK_BASIC_INFO ) ,
// / 获 取 更 详 细 的 内 存 信 息
func getDetailedMemoryInfo ( ) -> DetailedMemoryInfo {
let stats = getAccurateMemoryStats ( )
let processInfo = ProcessInfo . processInfo
return DetailedMemoryInfo (
residentMemoryMB : stats . residentMemoryMB ,
virtualMemoryMB : stats . virtualMemoryMB ,
physicalMemoryMB : stats . physicalMemoryMB ,
memoryPressure : getMemoryPressureLevel ( ) ,
availableMemoryMB : getAvailableMemoryMB ( ) ,
systemMemoryUsage : getSystemMemoryUsage ( ) ,
timestamp : Date ( )
)
}
// / 获 取 可 用 内 存
private func getAvailableMemoryMB ( ) -> Double {
// 简 化 版 本 ： 使 用 P r o c e s s I n f o 获 取 可 用 内 存 信 息
let processInfo = ProcessInfo . processInfo
let physicalMemory = Double ( processInfo . physicalMemory ) / 1024.0 / 1024.0
// 基 于 系 统 总 内 存 估 算 可 用 内 存
// 这 是 一 个 简 化 的 估 算 ， 实 际 应 用 中 可 能 需 要 更 复 杂 的 计 算
let estimatedAvailable = physicalMemory * 0.3 // 假 设 3 0 % 可 用
return estimatedAvailable
}
// / 获 取 系 统 内 存 使 用 情 况
private func getSystemMemoryUsage ( ) -> SystemMemoryUsage {
var stats = vm_statistics64 ( )
var count = mach_msg_type_number_t ( MemoryLayout < vm_statistics64 > . size / MemoryLayout < integer_t > . size )
let result = withUnsafeMutablePointer ( to : & stats ) {
$0 . withMemoryRebound ( to : integer_t . self , capacity : Int ( count ) ) {
host_statistics64 ( mach_host_self ( ) ,
HOST_VM_INFO64 ,
$0 ,
$0 ,
& count )
& count )
}
}
}
}
if kerr = = KERN_SUCCESS {
if result = = KERN_SUCCESS {
let usedMB = Double ( info . resident_size ) / 1024.0 / 1024.0
let pageSize = vm_kernel_page_size
let totalMB = Double ( ProcessInfo . processInfo . physicalMemory ) / 1024.0 / 1024.0
let freeMB = Double ( stats . free_count ) * Double ( pageSize ) / 1024.0 / 1024.0
let percentage = ( usedMB / totalMB ) * 100.0
let activeMB = Double ( stats . active_count ) * Double ( pageSize ) / 1024.0 / 1024.0
let inactiveMB = Double ( stats . inactive_count ) * Double ( pageSize ) / 1024.0 / 1024.0
let wiredMB = Double ( stats . wire_count ) * Double ( pageSize ) / 1024.0 / 1024.0
return ( usedMB , totalMB , percentage )
return SystemMemoryUsage (
} else {
freeMB : freeMB ,
return ( 0 , 0 , 0 )
activeMB : activeMB ,
inactiveMB : inactiveMB ,
wiredMB : wiredMB
)
}
return SystemMemoryUsage ( freeMB : 0 , activeMB : 0 , inactiveMB : 0 , wiredMB : 0 )
}
// / 获 取 内 存 压 力 等 级
private func getMemoryPressureLevel ( ) -> MemoryPressureLevel {
let stats = getAccurateMemoryStats ( )
let percentage = stats . physicalMemoryMB > 0 ? ( stats . residentMemoryMB / stats . physicalMemoryMB ) * 100.0 : 0.0
switch percentage {
case 0. . < 50 :
return . normal
case 50. . < 70 :
return . moderate
case 70. . < 85 :
return . high
case 85. . < 95 :
return . critical
default :
return . extreme
}
}
}
}
@ -87,15 +224,19 @@ class MemoryMonitor: ObservableObject {
print ( " 📊 当前内存使用: \( memoryUsage ) " )
print ( " 📊 当前内存使用: \( memoryUsage ) " )
// 解 析 内 存 使 用 量
let detailedInfo = getDetailedMemoryInfo ( )
if let usage = Double ( memoryUsage . replacingOccurrences ( of : " MB " , with : " " ) ) {
print ( " 📊 内存压力等级: \( detailedInfo . memoryPressure . description ) " )
if usage > 200 { // 超 过 2 0 0 M B
print ( " ⚠️ 内存使用过高，执行清理操作 " )
// 基 于 内 存 压 力 等 级 进 行 清 理
switch detailedInfo . memoryPressure {
case . high , . critical , . extreme :
print ( " ⚠️ 内存压力较高，执行清理操作 " )
performMemoryCleanup ( )
performMemoryCleanup ( )
} else if usage > 150 { // 超 过 1 5 0 M B
case . moderate :
print ( " ⚠️ 内存使用较高，建议清理 " )
print ( " ⚠️ 内存 压力中等 ，建议清理" )
suggestMemoryCleanup ( )
suggestMemoryCleanup ( )
}
case . normal :
print ( " ✅ 内存使用正常 " )
}
}
}
}
@ -296,3 +437,126 @@ extension MemoryMonitor {
extension Notification . Name { extension Notification . Name {
static let deepMemoryCleanup = Notification . Name ( " deepMemoryCleanup " )
static let deepMemoryCleanup = Notification . Name ( " deepMemoryCleanup " )
} }
// MARK: - 改 进 的 内 存 监 控 方 法
extension MemoryMonitor {
// / 获 取 更 准 确 的 系 统 内 存 信 息
func getSystemMemoryInfo ( ) -> SystemMemoryInfo {
let processInfo = ProcessInfo . processInfo
let physicalMemory = Double ( processInfo . physicalMemory ) / 1024.0 / 1024.0
// 获 取 当 前 应 用 的 内 存 使 用
let appMemory = getMemoryUsageInMB ( )
// 估 算 系 统 其 他 进 程 的 内 存 使 用
let systemMemory = physicalMemory - appMemory
return SystemMemoryInfo (
totalPhysicalMemoryMB : physicalMemory ,
appMemoryMB : appMemory ,
systemMemoryMB : max ( 0 , systemMemory ) ,
availableMemoryMB : getAvailableMemoryMB ( ) ,
memoryPressure : getMemoryPressureLevel ( )
)
}
// / 检 查 内 存 泄 漏
func checkMemoryLeak ( ) -> MemoryLeakReport {
let currentMemory = getMemoryUsageInMB ( )
// 记 录 内 存 使 用 历 史 （ 这 里 简 化 处 理 ， 实 际 应 用 中 应 该 保 存 历 史 数 据 ）
let report = MemoryLeakReport (
currentMemoryMB : currentMemory ,
memoryGrowth : 0 , // 需 要 历 史 数 据 来 计 算
potentialLeak : currentMemory > 300 , // 超 过 3 0 0 M B 可 能 有 问 题
recommendation : currentMemory > 300 ? " 内存使用过高，可能存在内存泄漏 " : " 内存使用正常 "
)
return report
}
// / 优 化 内 存 监 控 频 率
func optimizeMonitoringFrequency ( ) {
let memoryPressure = getMemoryPressureLevel ( )
switch memoryPressure {
case . normal :
// 正 常 情 况 ： 每 6 0 秒 检 查 一 次
updateMonitoringInterval ( 60.0 )
case . moderate :
// 中 等 压 力 ： 每 3 0 秒 检 查 一 次
updateMonitoringInterval ( 30.0 )
case . high :
// 高 压 力 ： 每 1 5 秒 检 查 一 次
updateMonitoringInterval ( 15.0 )
case . critical , . extreme :
// 严 重 压 力 ： 每 5 秒 检 查 一 次
updateMonitoringInterval ( 5.0 )
}
}
// / 更 新 监 控 间 隔
private func updateMonitoringInterval ( _ interval : TimeInterval ) {
stopMemoryMonitoring ( )
memoryCheckTimer = Timer . scheduledTimer ( withTimeInterval : interval , repeats : true ) { [ weak self ] _ in
self ? . checkMemoryPressure ( )
}
print ( " 📊 内存监控间隔已更新为 \( interval ) 秒 " )
}
// / 获 取 内 存 使 用 趋 势
func getMemoryTrend ( ) -> MemoryTrend {
// 这 里 应 该 基 于 历 史 数 据 计 算 趋 势
// 简 化 版 本 返 回 当 前 状 态
let currentMemory = getMemoryUsageInMB ( )
let pressure = getMemoryPressureLevel ( )
return MemoryTrend (
currentLevel : pressure ,
trend : . stable , // 需 要 历 史 数 据 来 判 断
recommendation : getMemoryOptimizationSuggestions ( ) . first ? ? " 内存使用正常 "
)
}
}
// MARK: - 新 增 数 据 结 构
struct SystemMemoryInfo {
let totalPhysicalMemoryMB : Double
let appMemoryMB : Double
let systemMemoryMB : Double
let availableMemoryMB : Double
let memoryPressure : MemoryPressureLevel
}
struct MemoryLeakReport {
let currentMemoryMB : Double
let memoryGrowth : Double
let potentialLeak : Bool
let recommendation : String
}
struct MemoryTrend {
let currentLevel : MemoryPressureLevel
let trend : MemoryTrendDirection
let recommendation : String
}
enum MemoryTrendDirection {
case increasing
case decreasing
case stable
var description : String {
switch self {
case . increasing :
return " 上升 "
case . decreasing :
return " 下降 "
case . stable :
return " 稳定 "
}
}
}
v504
1 year ago