About command parallelism...

[ks0927]

First of all, I'm sorry I'm a beginner about JDA and git.
I made three slash commands and one of them takes a long time.
I'm waiting for the command using deferReply().
If I use another command at this time, is there any way that the command is executed in parallel?

[MinnDevelopment]

There are a lot of things you can do to solve this problem, most importantly you should look into reducing how long your commands take.

• Do not use complete(), instead rely only on queue(...) callbacks
• Avoid using anything that is blocking, such as Thread.sleep(...) or Future#get

If you have a lot of CPU computations, for example due to image processing, then you will have to use a thread-pool instead. Note, however, that you are still limited by how much your CPU can handle at a time.

To use a thread-pool, make a globally accessible (e.g. static) field that you can re-use everywhere. This allows you to avoid leaking resources by creating excessive threads everywhere.

There are multiple types of pools you can use, but you most likely want a fixed size pool, unless you do some kind of heavy I/O bound tasks.

• Executors.newFixedThreadPool(amount) creates a pool with exactly amount number of available threads, this amount is usually chosen to be a factor of the available CPU cores.
• Executors.newScheduledThreadPool(amount) does the same thing, but allows you to use scheduling, like schedule(task, 10, TimeUnit.MINUTES) will run your task in 10 minutes
• Executors.newCachedThreadPool() create a pool with dynamically scaling threads, creating new ones on demand. This is primarily used for I/O bound tasks, such as reading/writing files or networking. Using this can result in some performance penalties due to the repeated creating and deleting of threads.

Here is an example use:

public class Globals {
    public static final int NUM_CORES = Runtime.getRuntime().availableProcessors();
    // Create a thread-pool with 2 or CPU core number of threads
    public static final ThreadPoolExecutor pool = Executors.newFixedThreadPool(Math.max(2, NUM_CORES));
}

public class ImageCommand extends ListenerAdapter {
    @Override
    public void onSlashCommandInteraction(SlashCommandInteractionEvent event) {
        // Reply before scheduling your task, just to be safe since it might take a moment for your task to run
        event.deferReply().queue();
        // Run your expensive task on a separate, but managed, thread
        Globals.pool.execute(() -> {
           Image someImage = getRandomImage();
           someImage = crazyExpensiveComputation(someImage);
           event.getHook().editOriginalAttachments(someImage.toInputStream()).queue();
        });
    }
}

Note: This will also prevent your program from stopping if you call jda.shutdown(), since it is unaware of your thread-pool. Those threads will continue to run even when JDA stops. There are 2 methods to solve this:

1. Call pool.shutdown() when you receive the ShutdownEvent
2. Mark your threads as daemon to prevent them from keeping the JVM alive

   Executors.newFixedThreadPool(amount, (task) -> {
      // This is called a thread factory
      Thread thread = new Thread(task, "My Custom Pool");
      thread.setDaemon(true); // mark as background thread
      return thread;
   })

[ks0927]

I'll apply it. Thank you!