Quản lý phụ thuộc khi khởi động ứng dụng

Trong quá trình phát triển ứng dụng Android, việc khởi tạo các thành phần (component) khi ứng dụng bắt đầu chạy là một bước quan trọng. Các module như mạng, cấu hình, hay phân tích dữ liệu thường có mối quan hệ phụ thuộc lẫn nhau. Nếu thứ tự khởi tạo không được kiểm soát chặt chẽ, ứng dụng có thể gặp lỗi runtime hoặc hoạt động không ổn định do truy cập vào các tài nguyên chưa sẵn sàng.

Thư viện Android Startup giải quyết vấn đề này bằng cách sử dụng thuật toán sắp xếp tô pô (Topological Sort). Cơ chế này giúp xác định trình tự khởi tạo tối ưu dựa trên đồ thị phụ thuộc, đảm bảo một thành phần chỉ được khởi tạo sau khi tất cả các thành phần mà nó phụ thuộc đã hoàn tất.

Nguyên lý hoạt động của thuật toán Topo

Các thành phần khởi động và mối quan hệ giữa chúng có thể được mô hình hóa dưới dạng đồ thị có hướng không chu trình (DAG). Thuật toán sắp xếp tô pô được áp dụng để duyệt đồ thị này nhằm tìm ra chuỗi thực thi hợp lệ. Trong Android Startup, quy trình này bao gồm các bước chính:

• Xây dựng đồ thị phụ thuộc từ danh sách các thành phần đăng ký.
• Tính toán bậc vào (in-degree) cho mỗi nút, tương ứng với số lượng phụ thuộc cần chờ.
• Sử dụng hàng đợi để xử lý các nút có bậc vào bằng 0 (không phụ thuộc thành phần nào khác).
• Phân loại nhiệm vụ vào luồng chính (Main Thread) hoặc luồng nền (IO Thread) dựa trên cấu hình.

Triển khai thuật toán sắp xếp

Đoạn mã dưới đây minh họa cách thức thư viện tính toán thứ tự thực thi. Logic này dựa trên thuật toán Kahn, sử dụng hàng đợi để quản lý các thành phần sẵn sàng khởi tạo.

fun resolveExecutionSequence(components: List<Startup<*>>): ExecutionPlan {
    // Chuẩn bị các cấu trúc dữ liệu
    val mainThreadTasks = mutableListOf<Startup<*>>()
    val backgroundTasks = mutableListOf<Startup<*>>()
    val registry = hashMapOf<String, Startup<*>>()
    val pendingQueue = ArrayDeque<String>()
    val dependentGraph = hashMapOf<String, MutableList<String>>()
    val dependencyCounter = hashMapOf<String, Int>()
    
    // Bước 1: Xây dựng đồ thị và đếm phụ thuộc
    components.forEach { component ->
        val id = component.identify()
        registry[id] = component
        dependencyCounter[id] = component.countDependencies()

        // Kiểm tra nếu thành phần không có phụ thuộc
        if (component.hasNoPrerequisites()) {
            pendingQueue.addLast(id)
        } else {
            // Xây dựng mối quan hệ cha - con
            component.prerequisites().forEach { parent ->
                val parentId = parent.identify()
                dependentGraph.getOrPut(parentId) { mutableListOf() }.add(id)
            }
        }
    }
    
    // Bước 2: Duyệt đồ thị để sắp xếp
    while (pendingQueue.isNotEmpty()) {
        pendingQueue.removeFirst()?.let { key ->
            registry[key]?.let { startup ->
                // Phân loại theo luồng thực thi
                if (startup.runOnUiThread()) {
                    mainThreadTasks.add(startup)
                } else {
                    backgroundTasks.add(startup)
                }
                
                // Cập nhật bậc vào cho các thành phần phụ thuộc
                dependentGraph[key]?.forEach { childId ->
                    val currentDegree = dependencyCounter[childId] ?: 0
                    dependencyCounter[childId] = currentDegree - 1
                    
                    if (dependencyCounter[childId] == 0) {
                        pendingQueue.addLast(childId)
                    }
                }
            }
        }
    }
    
    // Bước 3: Phát hiện phụ thuộc vòng tròn
    val totalProcessed = mainThreadTasks.size + backgroundTasks.size
    if (totalProcessed != components.size) {
        throw InitializationException("Phát hiện phụ thuộc vòng tròn hoặc thiếu cấu hình.")
    }
    
    return ExecutionPlan(backgroundTasks, mainThreadTasks, registry, dependentGraph)
}

Kịch bản phụ thuộc thực tế

Để minh họa rõ hơn, hãy xem xét một hệ thống gồm bốn thành phần khởi tạo. Thành phần LoggerInit không phụ thuộc vào gì cả, do đó nó sẽ được ưu tiên chạy đầu tiên. Ba thành phần còn lại là ConfigInit, DatabaseInit và NetworkInit đều cần LoggerInit hoàn tất.

Đặc biệt, NetworkInit còn phụ thuộc thêm vào cả ConfigInit và DatabaseInit. Thuật toán sẽ xử lý LoggerInit trước, sau đó giảm bậc vào của ba thành phần kia. Khi ConfigInit và DatabaseInit hoàn thành, bậc vào của NetworkInit về 0 và nó sẽ được khởi tạo. Cách tiếp cận này cho phép ConfigInit và DatabaseInit chạy song song nếu chúng không chạy trên luồng chính, giúp tối ưu hóa thời gian khởi động.

Hướng dẫn tích hợp vào dự án

Để áp dụng cơ chế này vào ứng dụng Android, developer cần thực hiện các bước cấu hình cơ bản sau:

1. Khai báo thành phần khởi tạo

Mỗi module cần khởi tạo sẽ được đóng gói trong một class kế thừa từ AndroidStartup. Developer cần định nghĩa rõ ràng các phụ thuộc và luồng thực thi.

class RemoteServiceBootstrap : AndroidStartup<ApiService>() {
    override fun create(context: Context): ApiService {
        // Khởi tạo client mạng
        return ApiService.Builder().build()
    }
    
    override fun requires(): List<Class<out Startup<*>>> {
        // Khai báo phụ thuộc vào cấu hình
        return listOf(SettingsBootstrap::class.java)
    }
    
    override fun runOnUiThread(): Boolean {
        // Thực thi trên luồng nền để không chặn UI
        return false
    }
}

2. Đăng ký trong Application

Tại class Application, sử dụng StartupManager để đăng ký các thành phần và kích hoạt quy trình khởi tạo.

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        
        StartupManager.Builder()
            .register(SettingsBootstrap())
            .register(DatabaseBootstrap())
            .register(RemoteServiceBootstrap())
            .initialize(this)
    }
}

Hệ thống sẽ tự động tính toán thứ tự dựa trên các khai báo requires() mà không cần developer can thiệp thủ công vào trình tự gọi hàm.

Lưu ý khi triển khai

Mặc dù cơ chế sắp xếp tô pô mang lại nhiều lợi ích, nhưng có một số điểm cần lưu ý để đảm bảo hiệu suất và稳定性:

• Tối giản phụ thuộc: Đồ thị phụ thuộc quá phức tạp sẽ làm tăng thời gian tính toán sắp xếp. Chỉ khai báo những phụ thuộc thực sự cần thiết.
• Quản lý luồng chính: Các thành phần chạy trên luồng chính sẽ được thực thi tuần tự. Nếu có quá nhiều task nặng ở đây, thời gian khởi động ứng dụng sẽ bị ảnh hưởng đáng kể.
• Xử lý khởi tạo bất đồng bộ: Đối với các thành phần cần thời gian khởi tạo lâu hoặc phụ thuộc vào kết quả bất đồng bộ, cần sử dụng các cơ chế chờ phù hợp như waitOnMainThread() để tránh lỗi truy cập null.
• Phát hiện lỗi sớm: Thư viện sẽ ném ngoại lệ nếu phát hiện phụ thuộc vòng tròn. Cần kiểm tra kỹ log khi tích hợp mới để đảm bảo đồ thị phụ thuộc hợp lệ.