iOS应用卡顿元凶曝光（Swift性能优化9大陷阱）

第一章：iOS应用卡顿元凶曝光（Swift性能优化9大陷阱）

过度使用闭包强引用

// 正确使用weak self避免循环引用
UIView.animate(withDuration: 0.3) { [weak self] in
    guard let self = self else { return }
    self.updateUI()
}

主线程执行耗时操作

1. 使用DispatchQueue.global()执行耗时任务
2. 在完成后切换回主线程更新UI

DispatchQueue.global(qos: .userInitiated).async {
    let imageData = try? Data(contentsOf: url)
    DispatchQueue.main.async {
        self.imageView.image = UIImage(data: imageData!)
    }
}

频繁触发视图布局更新

第二章：Swift性能优化核心策略

2.1 值类型与引用类型的合理选择：减少内存压力的理论与实践

性能对比场景

type User struct {
    ID   int
    Name string
}

// 值类型传递，复制开销大
func processUser(u User) { /* ... */ }

// 引用类型传递，避免复制
func processUserPtr(u *User) { /* ... */ }

内存分配建议

• 小对象（如基础类型、小型struct）优先使用值类型
• 大对象或需共享状态时使用引用类型
• 频繁修改的集合应使用指针以避免副本冗余

2.2 高效集合操作：避免O(n²)复杂度的遍历与查找技巧

利用哈希集合去重

func removeDuplicates(nums []int) []int {
    seen := make(map[int]bool)
    result := []int{}
    for _, num := range nums {
        if !seen[num] {
            seen[num] = true
            result = append(result, num)
        }
    }
    return result
}

常见操作复杂度对比

2.3 字符串拼接与格式化的性能陷阱及优化方案

常见性能陷阱

• fmt.Sprintf 在循环中频繁调用，开销较大
• 使用 += 进行多轮拼接，时间复杂度为 O(n²)

优化方案

var builder strings.Builder
builder.Grow(1024) // 预分配容量
for i := 0; i < 1000; i++ {
    builder.WriteString(strconv.Itoa(i))
}
result := builder.String()

2.4 懒加载与预加载的权衡：提升启动速度的实际应用

懒加载：按需加载降低初始负担

// 懒加载组件示例（React）
const LazyDashboard = React.lazy(() => import('./Dashboard'));
function App() {
  return (
    <Suspense fallback="Loading...">
      <LazyDashboard />
    </Suspense>
  );
}

预加载：提前准备换取响应速度

• 懒加载适合低频、非核心模块
• 预加载适用于高频访问或高延迟资源
• 混合策略常用于大型单页应用

2.5 循环强引用检测与弱引用实践：从代码层面杜绝内存泄漏

循环引用的典型场景

class NetworkManager {
    var completionHandler: (() -> Void)?
    
    func fetchData() {
        // 闭包强引用 self
        completionHandler = { 
            self.handleResponse() 
        }
    }
    
    func handleResponse() { }
}

弱引用的正确使用方式

completionHandler = { [weak self] in
    self?.handleResponse()
}

• weak：适用于可能为 nil 的情况，必须声明为可选类型
• unowned：适用于生命周期确定不为 nil，否则引发运行时错误

第三章：UI渲染与主线程优化

3.1 异步绘制与离屏渲染规避：提升界面流畅度的关键技术

异步绘制实现模式

UIGraphicsBeginImageContext(size)
DispatchQueue.global().async {
    let context = UIGraphicsGetCurrentContext()
    // 执行复杂路径绘制
    context?.setFillColor(UIColor.red.cgColor)
    context?.fill(CGRect(x: 0, y: 0, width: 100, height: 100))
    
    DispatchQueue.main.async {
        self.imageView.image = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
    }
}

let cell = tableView.dequeueReusableCell(withIdentifier: "MyCell", for: indexPath) as! MyTableViewCell

import _ "net/http/pprof"

// 启动服务后访问 /debug/pprof/profile 获取数据

DispatchQueue.main.async {
    self.label.text = "更新界面"
}

let operation1 = BlockOperation {
    print("Operation 1 completed")
}

let operation2 = BlockOperation {
    print("Operation 2 completed")
}

operation2.addDependency(operation1) // operation2 在 operation1 后执行
OperationQueue.main.addOperation(operation1)
OperationQueue.main.addOperation(operation2)

async function handleLogin(username, password) {
  const user = await User.findOne({ username }); // 数据库查询
  if (!user) throw new Error('User not found');
  
  const isValid = await bcrypt.compare(password, user.hash); // 异步解密
  if (!isValid) throw new Error('Invalid credentials');
  
  return generateJWT(user); // 生成令牌
}

Bitmap bitmap = memoryCache.get(url);
if (bitmap == null) {
    bitmap = decodeFromDiskCache(url); // 后台线程解码
    memoryCache.put(url, bitmap);
}
imageView.setImageBitmap(bitmap);

package main

import (
    "log"
    "sync"
)

var taskQueue = make(chan func(), 100)
var wg sync.WaitGroup

func worker() {
    for task := range taskQueue {
        wg.Add(1)
        go func(t func()) {
            defer wg.Done()
            t() // 执行任务
        }(task)
    }
}

func main() {
    go worker()
    // 提交日志写入任务
    taskQueue <- func() {
        log.Println("Async log entry")
    }
    close(taskQueue)
    wg.Wait()
}