在Java中，單線程實現異步可以使用以下幾種方式：

1. 使用線程池：創建一個線程池，通過提交任務到線程池中執行，任務可以是實現了Callable或Runnable接口的對象，線程池會為每個任務分配一個線程去執行，從而實現異步執行的效果。

ExecutorService executorService = Executors.newFixedThreadPool(1);
Future<Integer> future = executorService.submit(new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
        // 異步執行的代碼
        return 1;
    }
});

// 可以繼續執行其他的代碼

try {
    Integer result = future.get(); // 獲取異步執行的結果
    System.out.println(result);
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
}

executorService.shutdown(); // 關閉線程池

2. 使用定時任務：使用Timer類或ScheduledThreadPoolExecutor類來執行定時任務，通過指定延遲時間或者固定的時間間隔來執行任務，從而實現異步執行的效果。

Timer timer = new Timer();
timer.schedule(new TimerTask() {
    @Override
    public void run() {
        // 異步執行的代碼
    }
}, delay);

// 可以繼續執行其他的代碼

timer.cancel(); // 取消定時任務

3. 使用回調函數：將異步執行的結果通過回調函數的方式返回給調用方，從而實現異步的效果。

public interface Callback {
    void onSuccess(int result);
    void onFailure(Exception e);
}

public class AsynchronousTask {
    public static void execute(Callback callback) {
        new Thread(() -> {
            try {
                // 異步執行的代碼
                int result = 1;
                callback.onSuccess(result);
            } catch (Exception e) {
                callback.onFailure(e);
            }
        }).start();
    }
}

// 調用異步方法
AsynchronousTask.execute(new Callback() {
    @Override
    public void onSuccess(int result) {
        System.out.println(result);
    }

    @Override
    public void onFailure(Exception e) {
        e.printStackTrace();
    }
});

// 可以繼續執行其他的代碼

以上是三種常見的單線程實現異步的方式，根據具體的需求和場景可以選擇合適的方式來使用。