🧠 Part 1. 메모리 관리 — 앱이 터지는 진짜 이유

ㅋㅋㅋ 앱이 갑자기 꺼지는 경험... 개발자도 유저도 다 싫어하잖아.
근데 이게 대부분 메모리 문제야. 특히 모바일 환경에서는 데스크탑이랑 달리 메모리가 제한적이거든.
Android는 보통 앱당 256MB~512MB, iOS는 더 엄격하게 관리해. 이 한계를 넘으면? 앱이 그냥 죽어버려 😱

📌 메모리 누수(Memory Leak)란 뭔가요?

메모리 누수는 쉽게 말하면 더 이상 필요 없는 객체가 메모리에서 해제되지 않고 계속 남아있는 현상이야.
GC(Garbage Collector)가 있어도 참조가 살아있으면 못 지우거든. 이게 쌓이면 앱이 점점 느려지다가 결국 OOM(Out Of Memory) 크래시가 발생해.

대표적인 메모리 누수 패턴들을 알아보자!

🔴 Android에서 흔한 메모리 누수 패턴

// ❌ 이렇게 하면 안 됨 - Activity 메모리 누수 발생
class MySingleton {
    companion object {
        var context: Context? = null // Activity Context 저장 금지!
    }
}

// ✅ 이렇게 해야 함 - Application Context 사용
class MySingleton {
    companion object {
        lateinit var appContext: Context
        
        fun init(context: Context) {
            appContext = context.applicationContext // Application Context 사용!
        }
    }
}

// ❌ 위험한 코드
class MyActivity : AppCompatActivity() {
    private val handler = object : Handler(Looper.getMainLooper()) {
        override fun handleMessage(msg: Message) {
            // 여기서 Activity 참조 발생 → 누수!
            updateUI()
        }
    }
}

// ✅ WeakReference 사용으로 해결
class MyHandler(activity: MyActivity) : Handler(Looper.getMainLooper()) {
    private val weakActivity = WeakReference(activity)
    
    override fun handleMessage(msg: Message) {
        weakActivity.get()?.updateUI()
    }
}

// ✅ 올바른 리스너 관리
class MyActivity : AppCompatActivity() {
    private val locationListener = LocationListener { location ->
        // 위치 업데이트 처리
    }
    
    override fun onResume() {
        super.onResume()
        locationManager.requestLocationUpdates(
            LocationManager.GPS_PROVIDER, 0, 0f, locationListener
        )
    }
    
    override fun onPause() {
        super.onPause()
        locationManager.removeUpdates(locationListener) // 반드시 해제!
    }
}

🍎 iOS에서 흔한 메모리 누수 패턴

iOS는 ARC(Automatic Reference Counting)를 사용하는데, 이게 완벽한 게 아니야.
강한 참조 순환(Strong Reference Cycle)이 생기면 ARC도 해제를 못 해.

// ❌ 강한 참조 순환 - 메모리 누수 발생
class ViewController: UIViewController {
    var networkManager: NetworkManager?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        networkManager = NetworkManager()
        networkManager?.completion = {
            self.updateUI() // self를 강하게 참조 → 순환 참조!
        }
    }
}

// ✅ [weak self] 또는 [unowned self] 사용
networkManager?.completion = { [weak self] in
    guard let self = self else { return }
    self.updateUI() // 약한 참조로 순환 참조 방지
}

📊 메모리 최적화 핵심 전략들

1 객체 풀링(Object Pooling)

자주 생성/삭제되는 객체는 풀에서 재사용하자. RecyclerView가 바로 이 원리야!
매번 새 객체를 만들면 GC 압박이 심해지거든.

// 객체 풀 구현 예시 (Kotlin)
class ObjectPool<T>(
    private val maxSize: Int,
    private val factory: () -> T,
    private val reset: (T) -> Unit
) {
    private val pool = ArrayDeque<T>()
    
    fun acquire(): T {
        return if (pool.isEmpty()) {
            factory() // 풀이 비어있으면 새로 생성
        } else {
            pool.removeFirst() // 풀에서 재사용
        }
    }
    
    fun release(obj: T) {
        if (pool.size < maxSize) {
            reset(obj) // 초기화 후 풀에 반환
            pool.addLast(obj)
        }
    }
}

2 이미지 메모리 최적화

이미지는 메모리 먹는 하마야 🦛 ㅋㅋㅋ
4K 이미지 하나가 메모리에서 수십 MB를 차지할 수 있어. 반드시 최적화해야 해!

// Android - BitmapFactory.Options로 이미지 다운샘플링
fun decodeSampledBitmapFromResource(
    res: Resources,
    resId: Int,
    reqWidth: Int,
    reqHeight: Int
): Bitmap {
    return BitmapFactory.Options().run {
        inJustDecodeBounds = true
        BitmapFactory.decodeResource(res, resId, this)
        
        inSampleSize = calculateInSampleSize(this, reqWidth, reqHeight)
        inJustDecodeBounds = false
        
        BitmapFactory.decodeResource(res, resId, this)
    }
}

fun calculateInSampleSize(
    options: BitmapFactory.Options,
    reqWidth: Int,
    reqHeight: Int
): Int {
    val (height: Int, width: Int) = options.run { outHeight to outWidth }
    var inSampleSize = 1
    
    if (height > reqHeight || width > reqWidth) {
        val halfHeight: Int = height / 2
        val halfWidth: Int = width / 2
        
        while (halfHeight / inSampleSize >= reqHeight && 
               halfWidth / inSampleSize >= reqWidth) {
            inSampleSize *= 2
        }
    }
    return inSampleSize
}

3 캐시 전략 (LRU Cache)

LRU(Least Recently Used) 캐시는 가장 오래 사용 안 한 항목부터 제거하는 방식이야.
메모리 한계 내에서 최대한 효율적으로 데이터를 캐싱할 수 있어.

// Android LruCache 사용 예시
val maxMemory = (Runtime.getRuntime().maxMemory() / 1024).toInt()
val cacheSize = maxMemory / 8 // 전체 메모리의 1/8 사용

val memoryCache = object : LruCache<String, Bitmap>(cacheSize) {
    override fun sizeOf(key: String, bitmap: Bitmap): Int {
        return bitmap.byteCount / 1024
    }
}

// 캐시에 저장
fun addBitmapToMemoryCache(key: String, bitmap: Bitmap) {
    if (getBitmapFromMemCache(key) == null) {
        memoryCache.put(key, bitmap)
    }
}

// 캐시에서 가져오기
fun getBitmapFromMemCache(key: String): Bitmap? {
    return memoryCache.get(key)
}

🛠️ 메모리 프로파일링 도구

코드만 잘 짜는 게 아니라 실제로 메모리가 어떻게 사용되는지 측정해야 해.
도구 없이 감으로 최적화하는 건 눈 감고 운전하는 거랑 같아 ㅋㅋㅋ

// build.gradle에 추가
dependencies {
    debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.12'
}

// 끝! 별도 초기화 코드 없이 자동으로 누수 감지해줌 ㄷㄷ

🔋 Part 2. 배터리 소모 최소화 — 유저가 앱 지우는 이유

배터리 많이 먹는 앱은 유저가 바로 지워버려 😤
실제로 구글 플레이스토어 리뷰 보면 "배터리 너무 많이 먹어요" 이런 리뷰 엄청 많잖아.
배터리 최적화는 단순히 착한 개발자가 되는 게 아니라 앱 생존의 문제야!

⚡ 배터리를 가장 많이 먹는 주범들

📡 네트워크 최적화 — 배터리의 최대 적

네트워크 요청 하나 보낼 때마다 무선 라디오가 켜지는데, 이게 배터리를 엄청 먹어.
더 심각한 건 라디오가 켜진 후 약 20~30초 동안 활성 상태를 유지한다는 거야.
이걸 "Tail Time"이라고 하는데, 작은 요청 여러 번 보내는 게 큰 요청 한 번보다 훨씬 배터리를 더 먹어!

// ❌ 비효율적인 네트워크 사용 - 여러 번 나눠서 요청
fun loadUserData() {
    fetchUserProfile()      // 요청 1
    fetchUserPosts()        // 요청 2  
    fetchUserFollowers()    // 요청 3
    // 라디오가 3번 켜졌다 꺼짐 → 배터리 낭비!
}

// ✅ 배치 요청으로 최적화
fun loadUserDataOptimized() {
    // GraphQL이나 REST API 배치 엔드포인트 활용
    fetchAllUserData() // 한 번의 요청으로 모든 데이터 가져오기
    // 라디오가 1번만 켜짐 → 배터리 절약!
}

1 WorkManager로 백그라운드 작업 최적화 (Android)

WorkManager는 Android의 공식 백그라운드 작업 스케줄러야.
배터리 최적화, Doze 모드, 앱 종료 등 다양한 상황을 자동으로 처리해줘.

// WorkManager 사용 예시
class SyncWorker(
    context: Context,
    params: WorkerParameters
) : CoroutineWorker(context, params) {
    
    override suspend fun doWork(): Result {
        return try {
            syncDataWithServer()
            Result.success()
        } catch (e: Exception) {
            Result.retry()
        }
    }
}

// 제약 조건 설정 - 배터리 최적화의 핵심!
val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.CONNECTED) // 네트워크 연결 시에만
    .setRequiresBatteryNotLow(true)                // 배터리 부족 시 실행 안 함
    .setRequiresCharging(false)                    // 충전 중 아니어도 OK
    .build()

val syncRequest = PeriodicWorkRequestBuilder<SyncWorker>(
    repeatInterval = 15,
    repeatIntervalTimeUnit = TimeUnit.MINUTES
)
    .setConstraints(constraints)
    .build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "data_sync",
    ExistingPeriodicWorkPolicy.KEEP,
    syncRequest
)

2 Doze 모드와 App Standby 대응 (Android)

3 iOS Background Fetch 최적화

// iOS - Background App Refresh 최적화
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    func application(
        _ application: UIApplication,
        performFetchWithCompletionHandler completionHandler: 
        @escaping (UIBackgroundFetchResult) -> Void
    ) {
        // 백그라운드에서 데이터 가져오기
        fetchLatestData { result in
            switch result {
            case .success(let hasNewData):
                // 새 데이터가 있을 때만 newData 반환
                completionHandler(hasNewData ? .newData : .noData)
            case .failure:
                completionHandler(.failed)
            }
        }
    }
}

// Info.plist에 UIBackgroundModes 설정 필요
// fetch 모드 추가해야 함

📍 위치 서비스 최적화 — GPS는 배터리 킬러

GPS는 정말 배터리를 많이 먹어. 근데 많은 앱들이 필요 이상으로 정밀한 위치를 요청하거든.
앱의 목적에 맞는 최소한의 정확도만 요청하는 게 핵심이야!

// Android - 위치 정확도 레벨 선택
// 배터리 소모 순서: HIGH_ACCURACY > BALANCED > LOW_POWER > NO_POWER

// ❌ 항상 최고 정확도 요청 (배터리 낭비)
val locationRequest = LocationRequest.create().apply {
    priority = LocationRequest.PRIORITY_HIGH_ACCURACY
    interval = 1000 // 1초마다 업데이트
}

// ✅ 용도에 맞는 정확도 선택
val locationRequest = LocationRequest.Builder(
    Priority.PRIORITY_BALANCED_POWER_ACCURACY, // 균형 잡힌 정확도
    10000L // 10초마다 업데이트
).apply {
    setMinUpdateIntervalMillis(5000L) // 최소 5초 간격
    setMaxUpdateDelayMillis(30000L)   // 최대 30초 지연 허용
}.build()

// iOS - 위치 서비스 최적화
class LocationManager: NSObject, CLLocationManagerDelegate {
    private let locationManager = CLLocationManager()
    
    func setupLocationManager() {
        locationManager.delegate = self
        
        // 정확도 설정 - 앱 목적에 맞게 선택
        // kCLLocationAccuracyBest → 배터리 많이 먹음
        // kCLLocationAccuracyHundredMeters → 적당한 균형
        // kCLLocationAccuracyKilometer → 배터리 절약
        locationManager.desiredAccuracy = kCLLocationAccuracyHundredMeters
        
        // 이동 거리 필터 - 최소 이동 거리 이상일 때만 업데이트
        locationManager.distanceFilter = 50 // 50미터 이상 이동 시에만 업데이트
    }
    
    // 백그라운드에서는 significant location change만 사용
    func startMonitoringSignificantChanges() {
        locationManager.startMonitoringSignificantLocationChanges()
        // 일반 업데이트보다 훨씬 배터리 절약!
    }
}

🌙 화면 관련 배터리 최적화

화면은 스마트폰 배터리 소모의 큰 부분을 차지해.
앱이 화면을 불필요하게 켜두거나 밝게 유지하면 배터리가 급격히 줄어들어.

// Android - WakeLock 올바른 사용법
// WakeLock은 화면이 꺼져도 CPU를 깨어있게 함 → 배터리 소모!
class MyService : Service() {
    private var wakeLock: PowerManager.WakeLock? = null
    
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        val powerManager = getSystemService(POWER_SERVICE) as PowerManager
        
        // ✅ 필요한 최소한의 WakeLock 타입 사용
        wakeLock = powerManager.newWakeLock(
            PowerManager.PARTIAL_WAKE_LOCK, // CPU만 깨움 (화면은 끔)
            "MyApp::MyWakeLock"
        ).apply {
            acquire(10 * 60 * 1000L) // 최대 10분으로 제한!
        }
        
        return START_STICKY
    }
    
    override fun onDestroy() {
        wakeLock?.release() // 반드시 해제!
        super.onDestroy()
    }
}

⚡ Part 3. 렌더링 최적화 — 60fps의 세계

앱이 버벅거리는 느낌... 이거 진짜 최악이잖아 ㅋㅋㅋ
사람 눈은 초당 60프레임(60fps) 이상이면 부드럽다고 느끼는데,
이걸 유지하려면 각 프레임을 16.67ms 안에 처리해야 해.
이 시간을 넘기면 "프레임 드롭"이 발생하고 앱이 버벅거리는 거야!

🎨 Android 렌더링 최적화

1 레이아웃 계층 최소화

레이아웃이 깊어질수록 측정(Measure)과 배치(Layout) 시간이 늘어나.
ConstraintLayout을 사용하면 중첩 없이 복잡한 레이아웃을 만들 수 있어!

<!-- ❌ 깊은 중첩 레이아웃 - 렌더링 느림 -->
<LinearLayout>
    <LinearLayout>
        <RelativeLayout>
            <LinearLayout>
                <TextView />
                <ImageView />
            </LinearLayout>
        </RelativeLayout>
    </LinearLayout>
</LinearLayout>

<!-- ✅ ConstraintLayout으로 평탄화 - 렌더링 빠름 -->
<ConstraintLayout>
    <TextView
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent" />
    <ImageView
        app:layout_constraintTop_toBottomOf="@id/textView"
        app:layout_constraintStart_toStartOf="parent" />
</ConstraintLayout>

2 RecyclerView 최적화

리스트 화면은 앱에서 가장 많이 쓰이는 UI야. RecyclerView를 제대로 써야 해!

// RecyclerView 최적화 설정
recyclerView.apply {
    // 아이템 크기가 고정되면 성능 향상
    setHasFixedSize(true)
    
    // 미리 로드할 아이템 수 설정
    val layoutManager = LinearLayoutManager(context)
    layoutManager.initialPrefetchItemCount = 4
    this.layoutManager = layoutManager
    
    // 아이템 변경 애니메이션 비활성화 (필요 없을 때)
    (itemAnimator as? SimpleItemAnimator)?.supportsChangeAnimations = false
}

// ViewHolder에서 비용 비싼 작업 피하기
class MyViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
    private val textView: TextView = itemView.findViewById(R.id.text)
    private val imageView: ImageView = itemView.findViewById(R.id.image)
    
    fun bind(item: MyItem) {
        textView.text = item.title
        
        // ✅ Glide/Coil 같은 이미지 라이브러리 사용
        // 자동으로 캐싱, 다운샘플링, 비동기 로딩 처리
        Glide.with(itemView.context)
            .load(item.imageUrl)
            .placeholder(R.drawable.placeholder)
            .into(imageView)
    }
}

3 커스텀 뷰 최적화

커스텀 뷰를 만들 때 onDraw()에서 객체 생성하면 절대 안 돼!
매 프레임마다 호출되는 메서드에서 객체를 생성하면 GC 압박이 심해져서 프레임 드롭이 발생해.

// ❌ 잘못된 커스텀 뷰
class BadCustomView(context: Context) : View(context) {
    override fun onDraw(canvas: Canvas) {
        val paint = Paint() // 매 프레임마다 객체 생성! 절대 금지!
        val rect = RectF()  // 이것도 금지!
        canvas.drawRect(rect, paint)
    }
}

// ✅ 올바른 커스텀 뷰
class GoodCustomView(context: Context) : View(context) {
    // 클래스 레벨에서 미리 생성
    private val paint = Paint().apply {
        color = Color.BLUE
        style = Paint.Style.FILL
    }
    private val rect = RectF()
    
    override fun onDraw(canvas: Canvas) {
        rect.set(0f, 0f, width.toFloat(), height.toFloat())
        canvas.drawRect(rect, paint) // 재사용!
    }
    
    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
        super.onSizeChanged(w, h, oldw, oldh)
        // 크기 변경 시에만 계산
        rect.set(0f, 0f, w.toFloat(), h.toFloat())
    }
}

🍎 iOS 렌더링 최적화

1 셀 재사용과 비동기 처리

// iOS UITableView 최적화
class OptimizedTableViewController: UITableViewController {
    
    override func tableView(
        _ tableView: UITableView,
        cellForRowAt indexPath: IndexPath
    ) -> UITableViewCell {
        // ✅ 셀 재사용 - dequeueReusableCell 반드시 사용
        let cell = tableView.dequeueReusableCell(
            withIdentifier: "MyCell",
            for: indexPath
        ) as! MyCell
        
        let item = items[indexPath.row]
        cell.configure(with: item)
        
        return cell
    }
    
    // ✅ 셀 높이 미리 계산 (estimatedRowHeight 사용)
    override func viewDidLoad() {
        super.viewDidLoad()
        tableView.estimatedRowHeight = 80
        tableView.rowHeight = UITableView.automaticDimension
    }
}

// 이미지 비동기 로딩
class MyCell: UITableViewCell {
    private var imageLoadTask: URLSessionDataTask?
    
    func configure(with item: Item) {
        // 이전 로딩 작업 취소
        imageLoadTask?.cancel()
        
        // 비동기로 이미지 로딩
        imageLoadTask = URLSession.shared.dataTask(with: item.imageURL) { 
            [weak self] data, _, _ in
            guard let data = data, let image = UIImage(data: data) else { return }
            DispatchQueue.main.async {
                self?.imageView?.image = image
            }
        }
        imageLoadTask?.resume()
    }
    
    override func prepareForReuse() {
        super.prepareForReuse()
        imageLoadTask?.cancel() // 재사용 시 이전 작업 취소
        imageView?.image = nil
    }
}

2 Core Animation 최적화

// iOS 레이어 최적화
class OptimizedView: UIView {
    override func awakeFromNib() {
        super.awakeFromNib()
        
        // ✅ shouldRasterize - 자주 변하지 않는 복잡한 뷰에 사용
        layer.shouldRasterize = true
        layer.rasterizationScale = UIScreen.main.scale
        
        // ✅ drawsAsynchronously - 비동기 드로잉
        layer.drawsAsynchronously = true
        
        // ✅ 불투명 뷰는 isOpaque = true 설정
        // 투명도 계산을 건너뛰어서 렌더링 빨라짐
        isOpaque = true
        backgroundColor = .white
    }
}

🚀 Flutter 렌더링 최적화

요즘 Flutter 많이 쓰잖아? Flutter도 최적화 포인트가 있어!

// Flutter - const 생성자 활용
// ✅ const로 선언하면 위젯 재빌드 시 재생성 안 함
class MyWidget extends StatelessWidget {
  const MyWidget({super.key}); // const 생성자!
  
  @override
  Widget build(BuildContext context) {
    return const Column(
      children: [
        Text('Hello'), // const로 선언 가능
        Icon(Icons.star), // const로 선언 가능
      ],
    );
  }
}

// ✅ ListView.builder 사용 - 화면에 보이는 것만 렌더링
ListView.builder(
  itemCount: items.length,
  itemBuilder: (context, index) {
    return ListTile(
      title: Text(items[index].title),
    );
  },
)

// ❌ ListView(children: [...]) - 모든 아이템을 한 번에 렌더링
// 아이템이 많으면 절대 사용 금지!

// Flutter - RepaintBoundary로 불필요한 리페인트 방지
class MyAnimatedWidget extends StatefulWidget {
  @override
  Widget build(BuildContext context) {
    return Row(
      children: [
        // ✅ 애니메이션 부분만 RepaintBoundary로 감싸기
        RepaintBoundary(
          child: AnimatedContainer(
            duration: Duration(milliseconds: 300),
            // 이 부분만 리페인트됨
          ),
        ),
        // 이 부분은 애니메이션과 무관하게 리페인트 안 됨
        const Text('정적인 텍스트'),
      ],
    );
  }
}

🔧 Part 4. 비동기 처리 — 메인 스레드를 지켜라

메인 스레드(UI 스레드)에서 무거운 작업을 하면 앱이 얼어버려.
이걸 "ANR(Application Not Responding)"이라고 하는데, Android에서는 5초 이상 메인 스레드가 블로킹되면 ANR 다이얼로그가 뜨거든.
무거운 작업은 반드시 백그라운드 스레드에서! 이게 기본 중의 기본이야.

🔄 Kotlin Coroutines 활용

// Kotlin Coroutines - 비동기 처리의 정석
class MyViewModel : ViewModel() {
    
    fun loadData() {
        viewModelScope.launch {
            try {
                // ✅ IO 작업은 Dispatchers.IO에서
                val data = withContext(Dispatchers.IO) {
                    repository.fetchDataFromNetwork() // 네트워크 요청
                }
                
                // ✅ UI 업데이트는 Main에서 (launch는 기본이 Main)
                _uiState.value = UiState.Success(data)
                
            } catch (e: Exception) {
                _uiState.value = UiState.Error(e.message)
            }
        }
    }
    
    // ✅ 병렬 처리로 성능 향상
    fun loadMultipleData() {
        viewModelScope.launch {
            val userDeferred = async(Dispatchers.IO) { 
                repository.fetchUser() 
            }
            val postsDeferred = async(Dispatchers.IO) { 
                repository.fetchPosts() 
            }
            
            // 두 요청을 동시에 실행하고 둘 다 완료될 때까지 대기
            val user = userDeferred.await()
            val posts = postsDeferred.await()
            
            _uiState.value = UiState.Success(user, posts)
        }
    }
}

⚡ Swift Concurrency (async/await)

// iOS - Swift async/await
class DataViewModel: ObservableObject {
    @Published var data: [Item] = []
    @Published var isLoading = false
    
    func loadData() async {
        isLoading = true
        defer { isLoading = false }
        
        do {
            // ✅ async/await으로 깔끔한 비동기 처리
            let result = try await networkService.fetchItems()
            
            // ✅ UI 업데이트는 메인 액터에서
            await MainActor.run {
                self.data = result
            }
        } catch {
            print("Error: \(error)")
        }
    }
    
    // ✅ 병렬 처리
    func loadMultipleData() async {
        async let users = networkService.fetchUsers()
        async let posts = networkService.fetchPosts()
        
        do {
            let (fetchedUsers, fetchedPosts) = try await (users, posts)
            // 두 요청 동시 실행!
        } catch {
            print("Error: \(error)")
        }
    }
}

📊 Part 5. 성능 측정과 모니터링

최적화를 했으면 실제로 얼마나 개선됐는지 측정해야 해.
"느낌상 빨라진 것 같은데?" 이건 개발자가 할 말이 아니야 ㅋㅋㅋ
숫자로 증명해야 진짜 최적화야!

📱 Android 성능 측정 도구

// Android - 성능 측정 코드 삽입
// Systrace/Perfetto 마커 추가
class MyActivity : AppCompatActivity() {
    
    fun performHeavyOperation() {
        // 성능 측정 시작 마커
        Trace.beginSection("MyHeavyOperation")
        
        try {
            // 측정하고 싶은 코드
            processLargeDataSet()
        } finally {
            // 성능 측정 종료 마커
            Trace.endSection()
        }
    }
}

// Benchmark 라이브러리로 정밀 측정
@RunWith(AndroidJUnit4::class)
class MyBenchmark {
    @get:Rule
    val benchmarkRule = BenchmarkRule()
    
    @Test
    fun benchmarkMyOperation() {
        benchmarkRule.measureRepeated {
            // 측정할 코드
            myOperation()
        }
    }
}

🍎 iOS 성능 측정 도구

// iOS - os_signpost로 성능 마커 추가
import os.signpost

class MyViewController: UIViewController {
    private let log = OSLog(subsystem: "com.myapp", category: "Performance")
    
    func loadData() {
        let signpostID = OSSignpostID(log: log)
        
        os_signpost(.begin, log: log, name: "DataLoad", signpostID: signpostID)
        
        fetchData { [weak self] result in
            os_signpost(.end, log: log, name: "DataLoad", signpostID: signpostID)
            self?.processResult(result)
        }
    }
}

// XCTest Performance 측정
class PerformanceTests: XCTestCase {
    func testMyOperationPerformance() {
        measure {
            // 측정할 코드
            myOperation()
        }
    }
}

🌐 Firebase Performance Monitoring

실제 사용자 환경에서의 성능을 측정하려면 Firebase Performance Monitoring이 최고야.
개발 환경에서는 잘 되던 게 실제 기기에서 느릴 수 있거든!

// Android - Firebase Performance 커스텀 트레이스
val myTrace = Firebase.performance.newTrace("my_custom_trace")
myTrace.start()

// 측정하고 싶은 작업
performOperation()

myTrace.stop()

// 커스텀 메트릭 추가
myTrace.incrementMetric("items_processed", itemCount.toLong())

💡 Part 6. 실전 최적화 체크리스트

자, 이제 실전이야! 앱 출시 전에 반드시 확인해야 할 체크리스트를 정리했어.
재능넷 같은 플랫폼에서 앱 개발 관련 재능을 찾거나 제공할 때도 이런 최적화 지식이 있으면 훨씬 경쟁력 있어!

🎯 Part 7. 고급 최적화 기법들

📦 앱 크기 최적화 (APK/IPA 최적화)

앱 크기도 성능의 일부야! 앱이 크면 다운로드 시간도 길고, 설치 공간도 많이 차지해.
특히 인터넷이 느린 환경에서는 앱 크기가 설치율에 직접적인 영향을 줘.

// Android - R8/ProGuard로 코드 최소화
// build.gradle
android {
    buildTypes {
        release {
            minifyEnabled true          // 코드 최소화
            shrinkResources true        // 미사용 리소스 제거
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'),
                         'proguard-rules.pro'
        }
    }
    
    // App Bundle 사용 - 기기에 맞는 리소스만 다운로드
    bundle {
        language {
            enableSplit = true  // 언어별 분리
        }
        density {
            enableSplit = true  // 화면 밀도별 분리
        }
        abi {
            enableSplit = true  // CPU 아키텍처별 분리
        }
    }
}

🗜️ 이미지 최적화 전략

이미지는 앱 크기의 큰 부분을 차지해. 올바른 포맷 선택이 중요해!

🔐 데이터베이스 최적화

// Android Room DB 최적화
@Dao
interface UserDao {
    // ✅ 필요한 컬럼만 조회 (SELECT * 금지)
    @Query("SELECT id, name, email FROM users WHERE id = :userId")
    suspend fun getUserBasicInfo(userId: Long): UserBasicInfo
    
    // ✅ 인덱스 활용
    @Query("SELECT * FROM users WHERE email = :email")
    suspend fun getUserByEmail(email: String): User?
    
    // ✅ 페이징으로 대용량 데이터 처리
    @Query("SELECT * FROM posts ORDER BY created_at DESC")
    fun getPostsPaged(): PagingSource<Int, Post>
}

// 인덱스 설정
@Entity(
    tableName = "users",
    indices = [
        Index(value = ["email"], unique = true), // 이메일 인덱스
        Index(value = ["created_at"])             // 날짜 인덱스
    ]
)
data class User(
    @PrimaryKey val id: Long,
    val name: String,
    val email: String,
    val createdAt: Long
)

🌐 네트워크 캐싱 전략

// OkHttp 캐시 설정 (Android)
val cacheSize = 10L * 1024 * 1024 // 10MB 캐시
val cache = Cache(context.cacheDir, cacheSize)

val okHttpClient = OkHttpClient.Builder()
    .cache(cache)
    .addInterceptor { chain ->
        val request = chain.request()
        
        // 네트워크 없을 때 캐시 사용
        val modifiedRequest = if (!isNetworkAvailable()) {
            request.newBuilder()
                .header("Cache-Control", "public, only-if-cached, max-stale=86400")
                .build()
        } else {
            request.newBuilder()
                .header("Cache-Control", "public, max-age=60") // 60초 캐시
                .build()
        }
        
        chain.proceed(modifiedRequest)
    }
    .build()

🎓 Part 8. 플랫폼별 핵심 최적화 요약

재능넷에서 앱 개발 관련 재능을 공유하거나 의뢰할 때도, 이런 성능 최적화 지식을 갖춘 개발자를 찾는 게 중요해.
단순히 기능만 구현하는 게 아니라 성능까지 고려한 앱을 만드는 개발자가 진짜 실력자거든!

📱 Android 핵심 최적화 포인트

🍎 iOS 핵심 최적화 포인트

🐦 Flutter 핵심 최적화 포인트

🚀 Part 9. 실무에서 바로 쓰는 최적화 팁

💬 개발자들이 자주 놓치는 것들

🎯 성능 목표 설정하기

최적화를 하려면 목표가 있어야 해. 막연하게 "빠르게 만들자"가 아니라 구체적인 수치 목표를 세워야 해!

🔄 지속적인 성능 모니터링

최적화는 한 번 하고 끝이 아니야!
앱이 업데이트될수록 새로운 기능이 추가되고, 그 과정에서 성능이 저하될 수 있어.
CI/CD 파이프라인에 성능 테스트를 포함시켜서 지속적으로 모니터링해야 해.

// GitHub Actions에 성능 테스트 추가 예시
# .github/workflows/performance.yml
name: Performance Tests

on:
  pull_request:
    branches: [ main ]

jobs:
  benchmark:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Run Benchmark Tests
        run: ./gradlew :app:connectedBenchmarkAndroidTest
        
      - name: Upload Results
        uses: actions/upload-artifact@v3
        with:
          name: benchmark-results
          path: app/build/outputs/connected_android_test_additional_output/

🎉 마무리 — 최적화는 습관이다

자, 여기까지 왔어! 엄청난 양이었지? ㅋㅋㅋ
근데 이걸 다 외울 필요는 없어. 중요한 건 핵심 원칙을 이해하고 습관화하는 거야.

앱 개발은 단순히 기능을 만드는 게 아니야.
사용자가 쾌적하게 사용할 수 있는 경험을 만드는 것이 진짜 목표거든.
메모리 관리, 배터리 최적화, 렌더링 최적화 — 이 세 가지를 잘 잡으면 앱의 품질이 완전히 달라져!

오늘 배운 내용들을 하나씩 적용해보면서 실력을 키워봐.
처음엔 어렵게 느껴져도 하다 보면 자연스럽게 몸에 배거든.
그리고 막히는 부분이 있으면 재능넷에서 경험 많은 개발자들의 도움을 받는 것도 좋은 방법이야! 🚀