What code do you have exactly?

user=> (def pool (java.util.concurrent.Executors/newFixedThreadPool 1))
#'user/pool
user=> (.submit pool (fn []))
#object[java.util.concurrent.FutureTask 0x13047d7d "java.util.concurrent.FutureTask@13047d7d[Completed normally]"]
user=> 

This is dummy code I wrote in an effort to break the problem down but same issue

(let [ex (Executors/newFixedThreadPool 3)]
    (dotimes [n 3] (doto
                    ex
                     (.submit #(println (str "on thread no. " n))) .get)))

(let [e (Executors/newFixedThreadPool 1)]
    @(.submit e ^Callable (fn [] 3)))
3

check=> (let [e (Executors/newFixedThreadPool)]
          (.submit e (fn [] (println "HI!"))))
Syntax error (IllegalArgumentException) compiling . at (REPL:60:9).
No matching method newFixedThreadPool found taking 0 args for class java.util.concurrent.Executors

check=> (let [e (Executors/newFixedThreadPool 1)]
          @(.submit e ^Callable (fn [] 3)))
3
check=> (let [e (Executors/newFixedThreadPool 1)]
          (.submit e ^Runnable (fn [] (println "HI!"))))
#object[java.util.concurrent.FutureTask 0x14d5b143 "java.util.concurrent.FutureTask@14d5b143[Not completed, task = java.util.concurrent.Executors$RunnableAdapter@3112ad10[Wrapped task = check$eval9019$fn__9020@49452b11]]"]

Oh, that's curious - it works as is with def but not with let. Hmm.

Aha, I think I see where I went astray...I had the ^Callable hint in the body of my function like (fn ^Callable [] ...) which in hindsight makes little sense

@U2FRKM4TW if you (def ^:const pool ...) then it doesn't work again EDIT: but for an unrelated reason actually. Instead try

(def ^java.util.concurrent.ThreadPoolExecutor ex (java.util.concurrent.Executors/newFixedThreadPool 1))
(.submit ex (fn []))

@U2FRKM4TW what's your jvm version?

I think it has something to do with that the compiler knows the type of pool and let-locals, so when it tries to resolve the instance method it sees that there are two competing signatures

But when it sees (.submit pool (fn [])) without knowing the class of pool (ie. when deffing without the ^:const)it can't reflect and see the signatures of submit

@U11BV7MTK OpenJDK 11.0.16 on Ubuntu.

i thought it might be a new method but was mistaken

The issue is you cannot type hint a function literal for reasons I forget

So to completely get rid of reflection you need to hint both the executor and then let bind the fn and type hint the name, or do something like ^Callable (identity (fn [] ...))

> you cannot type hint a function literal But there's no reflection warnings on this, with type hinting on the function literal?

(.submit (java.util.concurrent.Executors/newFixedThreadPool 1) ^Callable (fn [] 1))

I must be misremembering something else

(can't figure out what I was thinking of, may just be completely mistaken)

@U0NCTKEV8 could that be in a core.async context rather than just Clojure at large?

I guess? Seems unlikely because with core.async you don't directly use executors. I just could have sworn I remembered that from fighting with type hinting executors in the past. There have been other issues in the past where reflection would non-deterministicly choose which overload it used

It seems that if when you don't provide enough hints at compile time, the runtime will resort to clojure.lang.Reflector/invokeInstanceMethod, which tries to choose the most specific method but ultimately is non-deterministic