// 基于 CADisplayLink 的 FPS 监控
class FPSMonitor {
    private var displayLink: CADisplayLink?
    private var lastTime: CFTimeInterval = 0
    private var count: Int = 0
    var fpsUpdate: ((Int) -> Void)?

    func start() {
        displayLink = CADisplayLink(target: self, selector: #selector(tick))
        displayLink?.add(to: .main, forMode: .common)
    }

    @objc private func tick(_ link: CADisplayLink) {
        if lastTime == 0 {
            lastTime = link.timestamp
            return
        }
        count += 1
        let delta = link.timestamp - lastTime
        if delta >= 1.0 {
            let fps = Int(round(Double(count) / delta))
            fpsUpdate?(fps)
            count = 0
            lastTime = link.timestamp
        }
    }

    func stop() {
        displayLink?.invalidate()
        displayLink = nil
    }
}

// ❌ 容易触发离屏渲染
imageView.layer.cornerRadius = 10
imageView.layer.masksToBounds = true

// ✅ 方案一：只对需要圆角的内容做裁剪，避免整层
imageView.layer.cornerRadius = 10
imageView.layer.masksToBounds = true
imageView.clipsToBounds = true  // 对 UIImageView 而言，用 clipsToBounds 配合 contentMode

// ✅ 方案二：用贝塞尔路径 + CAShapeLayer 做圆角（iOS 9+ 可考虑）
let path = UIBezierPath(roundedRect: bounds, cornerRadius: 10)
let mask = CAShapeLayer()
mask.path = path.cgPath
layer.mask = mask  // 仍可能离屏，需实测

// ✅ 方案三：直接用圆角图片（切图或 Core Graphics 绘制）
// 在子线程绘制圆角图片，主线程只做 display

// ❌ 阴影 + 裁剪容易离屏
view.layer.shadowOpacity = 0.5
view.layer.cornerRadius = 10
view.layer.masksToBounds = true  // 与 shadow 冲突

// ✅ 分到两个 layer：容器负责阴影，子 layer 负责圆角
let containerView = UIView()
containerView.layer.shadowOpacity = 0.5
containerView.layer.shadowRadius = 4
containerView.layer.shadowOffset = .zero

let contentView = UIView()
contentView.layer.cornerRadius = 10
contentView.layer.masksToBounds = true
contentView.frame = containerView.bounds
contentView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
containerView.addSubview(contentView)

// 已知不透明时
view.layer.opaque = true
view.backgroundColor = .white  // 明确不透明色

// ❌ 在主线程做重活
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) as! MyCell
    let model = dataSource[indexPath.row]
    cell.imageView?.image = UIImage(contentsOfFile: model.imagePath)  // 同步读盘 + 解码
    cell.label.text = heavyCompute(model)  // 复杂计算
    return cell
}

// ✅ 异步加载图片 + 计算放子线程
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) as! MyCell
    let model = dataSource[indexPath.row]
    cell.tag = indexPath.row
    cell.label.text = nil
    cell.imageView?.image = nil

    DispatchQueue.global().async {
        let image = self.loadImage(path: model.imagePath)
        let text = self.heavyCompute(model)
        DispatchQueue.main.async {
            if cell.tag == indexPath.row {
                cell.imageView?.image = image
                cell.label.text = text
            }
        }
    }
    return cell
}

// 利用 RunLoop 在空闲时预加载
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = ...
    preloadIfNeeded(at: indexPath)
    return cell
}

private func preloadIfNeeded(at indexPath: IndexPath) {
    let maxIndex = min(indexPath.row + 5, dataSource.count - 1)
    for i in (indexPath.row + 1)...maxIndex {
        if !imageCache.isCached(for: dataSource[i].imagePath) {
            DispatchQueue.global().async {
                _ = self.loadImage(path: self.dataSource[i].imagePath)
            }
        }
    }
}

// 在子线程解码
func decodeImage(_ image: UIImage) -> UIImage? {
    UIGraphicsBeginImageContextWithOptions(image.size, true, 0)
    image.draw(at: .zero)
    let decoded = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()
    return decoded
}

// 或使用 ImageIO 指定解码选项
// 对于网络图片，使用 SDWebImage / Kingfisher 等库，它们会在后台解码

// ❌ block 强引用 self，self 强引用持有 block 的成员
class ViewController: UIViewController {
    var onComplete: (() -> Void)?
    func setup() {
        onComplete = {
            self.doSomething()  // 强引用 self
        }
    }
}

// ✅ weak self
onComplete = { [weak self] in
    self?.doSomething()
}

// ✅ weak + strong 避免 block 执行期间 self 被释放
onComplete = { [weak self] in
    guard let self = self else { return }
    self.doSomething()
}

// 大图使用 imageWithContentsOfFile 或 UIImage(contentsOfFile:) 避免缓存
let image = UIImage(contentsOfFile: path)

// 或使用 ImageIO 进行缩略图解码，减少内存
let options: [CFString: Any] = [
    kCGImageSourceCreateThumbnailFromImageIfAbsent: true,
    kCGImageSourceThumbnailMaxPixelSize: 200
]
// 只解码缩略图尺寸，而非整张大图

// 串行改并行
func application(_ application: UIApplication, didFinishLaunchingWithOptions...) -> Bool {
    // 可并行的初始化
    DispatchQueue.global().async { initAnalytics() }
    DispatchQueue.global().async { initCrashReporter() }
    DispatchQueue.global().async { initNetworkConfig() }

    // 必须主线程且阻塞首屏的，尽量后置或精简
    setupWindow()
    return true
}

// 非首屏必需的模块，等首屏展示后再初始化
DispatchQueue.main.async {
    self.window?.rootViewController = MainTabBarController()
    DispatchQueue.main.async {
        // 首屏渲染完成后再做
        initThirdPartySDK()
    }
}

// 请求合并示例（伪代码）
class RequestMerger {
    private var pendingRequests: [String: [CompletionHandler]] = [:]
    private var inflight: [String: URLSessionTask] = [:]

    func fetch(key: String, completion: @escaping (Data?) -> Void) {
        if let task = inflight[key] {
            // 合并到同一请求的回调
            pendingRequests[key, default: []].append(completion)
            return
        }
        let task = URLSession.shared.dataTask(with: url) { data, _, _ in
            let handlers = self.pendingRequests.removeValue(forKey: key) ?? []
            DispatchQueue.main.async {
                handlers.forEach { $0(data) }
            }
        }
        task.resume()
        inflight[key] = task
    }
}

// 大文件流式读取
if let stream = InputStream(fileAtPath: path) {
    stream.open()
    defer { stream.close() }
    let bufferSize = 1024 * 64
    var buffer = [UInt8](repeating: 0, count: bufferSize)
    while stream.hasBytesAvailable {
        let read = stream.read(&buffer, maxLength: bufferSize)
        // 处理 buffer
    }
}

DispatchQueue.global(qos: .userInitiated).async {
    let result = expensiveComputation()
    DispatchQueue.main.async {
        self.updateUI(with: result)
    }
}

// 为不同任务类型使用不同队列，避免单一队列过长
let imageQueue = DispatchQueue(label: "com.app.image", qos: .userInitiated)
let dbQueue = DispatchQueue(label: "com.app.db", qos: .utility)

// 读多写少场景，可用 dispatch_barrier 优化
class ThreadSafeArray<Element> {
    private var array: [Element] = []
    private let queue = DispatchQueue(label: "com.app.safe", attributes: .concurrent)

    func append(_ element: Element) {
        queue.async(flags: .barrier) { self.array.append(element) }
    }

    var last: Element? {
        queue.sync { array.last }
    }
}