Use single AsyncExecutor for all operations

[BaurzhanSakhariev]

Operator creation creates num_cores worker threads
https://github.com/apache/opendal/blob/main/bindings/java/src/executor.rs#L113-L118

I did a simple test by running 1000 threads each creating an Operator. I saw a lot of daemon threads (Thread-1 ... Thread-1000) in the thread dump and tried to use AsyncOperator constructor accepting AsyncExecutor as a parameter.

I have a static single instance which I created only once:

public static final AsyncExecutor ASYNC_EXECUTOR = AsyncExecutor.createTokioExecutor(Runtime.getRuntime().availableProcessors());

And then I create Operator like Operator operator = AsyncOperator.of(NAME, config, ASYNC_EXECUTOR).blocking()

Still seeing massive amount of daemon threads, even though executor supposed to be re-used?
https://github.com/apache/opendal/blob/main/bindings/java/src/executor.rs#L147-L148

[BaurzhanSakhariev]

Ok, problem was in closing OperatorOutputStream and Operator.

My understanding is that freeing resources implicitly destroys executor and it had to be re-created.

[BaurzhanSakhariev]

Oops, I was just too slow second time when monitoring threads, keeping stream/operator open doesn't help.

I checked "All threads" instead of "Finished" and again saw 1000 threads. Also, singleton AsyncExecutor is not "destroyed", I added some dummy code like

if (ASYNC_EXECUTOR.isDisposed()) {
    throw new IllegalStateException("EXECUTOR HAS BEEN DISPOSED!");
}

and haven't seen this exception, so basically executor is not re-used and it's not that it's being disposed

[Xuanwo]

Hi, @tisonkun, would you like to take a look? I believe there are some incorrect usages of the operator class.

[tisonkun]

@BaurzhanSakhariev could you provide a complete reproduce?

I check the code and the default_executor reuse the global RUNTIME.

With fragmented comments it's hard to understand how your application create threads and how they leak.

[tisonkun]

I support the Thread- is your created thread.

[tisonkun]

Tested and confirmed that the threads are reused.

Thread-1024 ~ Thread-1035 are OpenDAL threads. The available cores on my laptop are 12.

    @Test
    void testMassiveOperator() throws Exception {
        final CountDownLatch latch = new CountDownLatch(1);
        final CountDownLatch inner = new CountDownLatch(1024);
        final Map<String, String> conf = new HashMap<>();
        conf.put("root", "/opendal/");

//        final int n = 1;
//        try {
//            @Cleanup final AsyncOperator op = AsyncOperator.of("memory", conf);
//            op.write("key-" + n, ("v" + n).getBytes(StandardCharsets.UTF_8)).join();
//            latch.await();
//        } catch (Exception e) {
//            throw Lombok.sneakyThrow(e);
//        }

        for (int i = 0; i < 1024; i++) {
            final int n = i;
            final Thread thread = new Thread(() -> {
                try {
                    @Cleanup final AsyncOperator op = AsyncOperator.of("memory", conf);
                    op.write("key-" + n, ("v" + n).getBytes(StandardCharsets.UTF_8)).join();
                    inner.countDown();;
                    latch.await();
                } catch (Exception e) {
                    throw Lombok.sneakyThrow(e);
                }
            });
            thread.setName("AsyncOperator-" + i);
            thread.start();
        }

        inner.await();
        latch.countDown();
    }
}

[BaurzhanSakhariev]

Hi @tisonkun, thanks for checking.

I support the Thread- is your created thread.

you are absolutely right, I was too focused on the prev discussion about Thread-x pattern and forgot that my threads can also have default pattern.

I run my test again but this time I assigned some custom prefix to my threads and can confirm that I see only num_processors OpenDAL threads having names with the pattern Thread-x.

Thanks!