public void run() throws SchedulerException {
        // 1. Khởi tạo rpc server
        this.masterRPCServer.start();

        // 2. Cài đặt plugin tác vụ
        this.taskPluginManager.loadPlugin();

        // 3. Tự chịu lỗi
        this.masterRegistryClient.start();
        this.masterRegistryClient.setRegistryStoppable(this);

        // 4. Lập lịch Master
        this.masterSchedulerBootstrap.init();
        this.masterSchedulerBootstrap.start();

        // 5. Dịch vụ thực thi sự kiện
        this.eventExecuteService.start();
        // 6. Cơ chế chịu lỗi
        this.failoverExecuteThread.start();

        // 7. Lập lịch Quartz
        this.schedulerApi.start();
        ...
    }

 public void start() {
         ...
        // Bộ xử lý yêu cầu thực thi tác vụ
        this.nettyRemotingServer.registerProcessor(CommandType.TASK_EXECUTE_RUNNING, taskExecuteRunningProcessor);
        // Bộ xử lý yêu cầu kết quả thực thi tác vụ
        this.nettyRemotingServer.registerProcessor(CommandType.TASK_EXECUTE_RESULT, taskExecuteResponseProcessor);
        // Bộ xử lý yêu cầu kết thúc tác vụ
        this.nettyRemotingServer.registerProcessor(CommandType.TASK_KILL_RESPONSE, taskKillResponseProcessor);
        ...
        this.nettyRemotingServer.start();
        logger.info("Đã khởi động Master RPC Server...");
    }

public void start() {
        try {
            this.masterHeartBeatTask = new MasterHeartBeatTask(masterConfig, registryClient);
            // 1. Đăng ký bản thân vào registry;
            registry();
            // 2. Lắng nghe trạng thái kết nối với registry;
            registryClient.addConnectionStateListener(
                    new MasterConnectionStateListener(masterConfig, registryClient, masterConnectStrategy));
            // 3. Lắng nghe trạng thái của các master và worker khác trong registry và thực hiện công việc chịu lỗi
            registryClient.subscribe(REGISTRY_DOLPHINSCHEDULER_NODE, new MasterRegistryDataListener());
        } catch (Exception e) {
            throw new RegistryException("Lỗi khởi động client đăng ký master", e);
        }
    }

public void run() {
        while (!ServerLifeCycleManager.isStopped()) {
            try {
                // Nếu server không ở trạng thái đang chạy, không thể tiêu thụ lệnh
                if (!ServerLifeCycleManager.isRunning()) {
                    logger.warn("Server hiện tại {} không ở trạng thái đang chạy, không thể tiêu thụ lệnh.", this.masterAddress);
                    Thread.sleep(Constants.SLEEP_TIME_MILLIS);
                }

                // Xử lý quá tải khối lượng công việc (CPU/bộ nhớ)
                boolean isOverload = OSUtils.isOverload(masterConfig.getMaxCpuLoadAvg(), masterConfig.getReservedMemory());
                if (isOverload) {
                    logger.warn("Server hiện tại {} đang quá tải, không thể tiêu thụ lệnh.", this.masterAddress);
                    MasterServerMetrics.incMasterOverload();
                    Thread.sleep(Constants.SLEEP_TIME_MILLIS);
                    continue;
                }

                // Lấy lệnh từ cơ sở dữ liệu
                List<Command> commands = findCommands();
                if (CollectionUtils.isEmpty(commands)) {
                    Thread.sleep(Constants.SLEEP_TIME_MILLIS);
                    continue;
                }

                // Chuyển đổi lệnh thành các phiên bản xử lý và xử lý logic workflow
                List<ProcessInstance> processInstances = command2ProcessInstance(commands);
                if (CollectionUtils.isEmpty(processInstances)) {
                    Thread.sleep(Constants.SLEEP_TIME_MILLIS);
                    continue;
                }

                // Xử lý thực thi phiên bản workflow
                processInstances.forEach(processInstance -> {
                    try {
                        LoggerUtils.setWorkflowInstanceIdMDC(processInstance.getId());
                        WorkflowExecuteRunnable workflowRunnable = new WorkflowExecuteRunnable(processInstance, ...);
                        processInstanceExecCacheManager.cache(processInstance.getId(), workflowRunnable);
                        workflowEventQueue.addEvent(new WorkflowEvent(WorkflowEventType.START_WORKFLOW, processInstance.getId()));
                    } finally {
                        LoggerUtils.removeWorkflowInstanceIdMDC();
                    }
                });
            } catch (InterruptedException interruptedException) {
                logger.warn("Khởi động lập lịch master bị gián đoạn, đóng vòng lặp", interruptedException);
                Thread.currentThread().interrupt();
                break;
            } catch (Exception e) {
                logger.error("Lỗi workflow lập lịch master", e);
                ThreadUtils.sleep(Constants.SLEEP_TIME_MILLIS);
            }
        }
    }

public void run() {
        while (!ServerLifeCycleManager.isStopped()) {
            try {
                // Xử lý các sự kiện thực thi workflow
                workflowEventHandler();
                // Xử lý các sự kiện thực thi tác vụ stream
                streamTaskEventHandler();
                TimeUnit.MILLISECONDS.sleep(Constants.SLEEP_TIME_MILLIS_SHORT);
            } ...
        }
    }

public void checkMasterFailover() {
        List<String> needFailoverMasterHosts = processService.queryNeedFailoverProcessInstanceHost()
                .stream()
                .filter(host -> localAddress.equals(host) || !registryClient.checkNodeExists(host, NodeType.MASTER))
                .distinct()
                .collect(Collectors.toList());
        if (CollectionUtils.isEmpty(needFailoverMasterHosts)) {
            return;
        }

        for (String needFailoverMasterHost : needFailoverMasterHosts) {
            failoverMaster(needFailoverMasterHost);
        }
    }