How xxl-job Leverages Netty, Dynamic Proxies, and Async Queues for High‑Throughput RPC

xxl-job uses Netty HTTP for communication, although other protocols like Mina, Jetty, and Netty TCP are supported; the implementation hard‑codes Netty HTTP.

When the scheduler notifies an executor to run a task, the overall processing flow is illustrated in the diagram below.

The design includes several notable points:

Dynamic proxy pattern – ExecutorBiz and AdminBiz interfaces encapsulate heartbeat, pause, trigger, registration, and callback operations; the implementation classes contain no communication logic. XxlRpcReferenceBean generates a proxy object that performs remote calls.

Full asynchronous processing – The executor deserializes incoming messages, stores task information in a LinkedBlockingQueue, and worker threads fetch tasks from the queue for execution. Task results are placed in a callback queue, reducing Netty worker thread time and increasing throughput.

Asynchronous wrapper – Although the scheduler appears to call synchronously, the XxlJobTrigger.runExecutor method shows how the result is obtained after asynchronous handling.

Key code snippet for the scheduler:

public static ReturnT<String> runExecutor(TriggerParam triggerParam, String address) {
    ReturnT<String> runResult = null;
    try {
        ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(address);
        // This part performs many async operations and finally gets a synchronous result
        runResult = executorBiz.run(triggerParam);
    } catch (Exception e) {
        logger.error(">>>>>>>>>>> xxl-job trigger error, please check if the executor[{}] is running.", address, e);
        runResult = new ReturnT<String>(ReturnT.FAIL_CODE, ThrowableUtil.toString(e));
    }
    StringBuffer runResultSB = new StringBuffer(I18nUtil.getString("jobconf_trigger_run") + "：");
    runResultSB.append("<br>address：").append(address);
    runResultSB.append("<br>code：").append(runResult.getCode());
    runResultSB.append("<br>msg：").append(runResult.getMsg());
    runResult.setMsg(runResultSB.toString());
    return runResult;
}

The dynamic proxy creates an XxlRpcFutureResponse, sends the request asynchronously with client.asyncSend, and then blocks using futureResponse.get(timeout, TimeUnit.MILLISECONDS) until the response arrives.

The XxlRpcFutureResponse class implements thread waiting and notification; each remote call carries a UUID request ID that acts as a key to locate the corresponding future response and wake the waiting thread.

Overall, the combination of Netty, dynamic proxies, and asynchronous queues provides a high‑throughput, low‑latency RPC mechanism for xxl‑job.