All the thread of pool are WAITING (parking)

Question

I used a thread pool like this: new ThreadPoolExecutor(8, 8, 8, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(2048)); Run it and submit tasks in parallel for a while, then use FutureTask to get the result. It seems normal at the beginning, but all of the 8 threads of the pool become WAITING (parking) state very soon. No any one thread could be running again and the task queue become more and more longer. I look at the FutureTask.awaitDone() briefly, I think maybe it's the last line code LockSupport.park(this) cause this state. So, what should I do to avoid the state for these threads?

Actual codes(Project based on SpringBoot):

public class MyAsyncConfigurerSupport extends AsyncConfigurerSupport {

    @Bean
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(8);
        executor.setMaxPoolSize(8);
        executor.setKeepAliveSeconds(8);
        executor.setQueueCapacity(2048);
        executor.setAllowCoreThreadTimeOut(true);
        executor.setRejectedExecutionHandler((Runnable r, ThreadPoolExecutor exe) -> {
            throw new RuntimeException("TooBusy");
        });
        return executor;
    }
}

public class MyController {

    @Autowired
    private MyService service;

    public String get(String key) {
        Future<String> future = service.getSomeThing(key);
        // numbers of same kind of futures
        return future.get();
    }
}

@Service
public class MyService {
    @Async
    public Future<String> getSomeThing(String key) {
        // Call remote http server
        String result = feignClient.callAPI(key);
        return new AsyncResult<>(result);
    }
}

Another kind of ~~deadlock~~ endless loop (fixed on new version of jdk, replaced with a Recursive update Exception):

    Map<String, Object> concurrentMap = new ConcurrentHashMap<>();
    concurrentMap.computeIfAbsent("ABC", k -> {
        Object obj = new Object();
        concurrentMap.put("ABC", obj);
        return obj;
    });

Show us the actual code - it's usually much easier to understand than just a description of code. — Amongalen, Jul 16 '20 at 08:47
show the actual code in `getSomeThing ` method,not just a brief demo, the code u think unrelevant may be important to find the problem — neo, Jul 16 '20 at 09:31
Actually, there just has a feignClient to call another restful api server — wangkui, Jul 16 '20 at 10:25
From the code you posted I missed where is the task queue and how are you invoking executor. Can you add that? — Piro, Jul 16 '20 at 10:45
I set the ```QueueCapacity=2048``` and the ```ThreadPoolTaskExecutor.createQueue``` will use ```LinkedBlockingQueue```, the Spring will use this ```ThreadPoolTaskExecutor``` to execute task when call the method with ```@Async``` — wangkui, Jul 16 '20 at 10:51

score 0 · Answer 1 · answered Jul 27 '20 at 04:04

Sorry guys, because my project is huge, so the actual codes above (which I think is the actual codes almost) is not the real actual codes. Now I find out the primary cause and these simple codes following could reproduce it.

public static void main(String[] args) {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(4);
    executor.setMaxPoolSize(4);
    executor.setKeepAliveSeconds(4);
    executor.setQueueCapacity(1024);
    executor.setBeanName("AA");
    executor.setRejectedExecutionHandler((Runnable r, ThreadPoolExecutor exe) -> {
        throw new RuntimeException("TooBusy");
    });
    executor.initialize();

    for (int i = 0; i < 4; i++) {
        executor.execute(() -> {
            Future<Long> f = executor.submit(System::currentTimeMillis);
            try {
                f.get();
            } catch (Exception e) {
            }
        });
    }
}

Just because there has nestification of async execute. The 1st level tasks used all of the threads, then the 2nd level tasks have no chance to be executed, but the 1st level tasks are waiting for the results of 2nd level tasks, so, all of them are WAITING (parking)

All the thread of pool are WAITING (parking)

1 Answers1