referencia a presentar es ambiguo: <t>present(Callable)<t>) en ExecutorServicio y método de envío(Runnable) en Executor</t></t>

Estoy registrando un callable y guardándolo en un futuro objeto como este:

final Future objectFuture= Executors.newFixedThreadPool(5).submit(
                    () -> methodReturnsSomeObject(someValue));

Estoy recibiendo el siguiente error de compilación pero su edificio localmente:

[INFO] -------------------------------------------------------------
[ERROR] COMPILATION ERROR : 
[INFO] -------------------------------------------------------------
[ERROR] /c:/1/5889/001/target/clover/src/com/... reference to submit is ambiguous

ambos método submit(java.util.concurrent.Callable) en java.util.concurrent.EjecutorServicio y método submit(java.lang.Runnable) en java.util.concurrent.

Esto sucede cuando hay ambigüedad en métodos sobrecargados, por ejemplo. Integer... e int... Error del compilador : referencia al llamado ambiguo. No veo por qué muestra esto aquí. Estoy claramente pasando un Callable aquí en el método anterior. Por favor hágame saber cómo es ambiguo? Además, ya que mi maven build está pasando localmente y no en Jenkins, ¿necesito mirar la configuración del servidor Jenkins? Gracias por adelantado

Versión Java: 1.8 Versión de Maven: 3.0.5

Pregunta hecha hace 3 años, 4 meses, 29 días - Por syntaxsniper

3 Respuestas:

• submit() tiene 2 sobrecargas con un argumento. Los argumentos son ambas interfaces funcionales, con los siguientes métodos:

  • submit(Callable task): T call()
  • submit(Runnable task): void run()

  Tu expresión de lambda es () -> methodReturnsSomeObject(someValue).

  Si el método no hubiera devuelto nada, es decir, era un void método, sólo podría implementar RunnableAsí que no habría habido ambigüedad.

  Pero ya que el método tiene un valor de retorno que coincide T ()SomeObject en su caso), la expresión lambda puede implementar Callable, pero también puede implementar Runnable ignorando/desechando el valor de retorno. Tenerlo en práctica Callable es, por supuesto, preferible.

  Tenga en cuenta que algunos compiladores resolverán Callable, especialmente nuevas versiones del compilador, que habrá mejorado el manejo de inferencias, por lo que no siempre experimentará este problema.

  Para resolver una ambigüedad, diríjase al tipo de parámetro que desee. En este caso, deseamos CallableAsí que...

  final Future objectFuture = Executors.newFixedThreadPool(5).submit(
                      (Callable) () -> methodReturnsSomeObject(someValue));
  

  Respondida el Dec 17, 2020 a las 02:21 - por bytebarricade

  Votos positivos: 0 | Votos negativos: 0

  Votar positivo

  Votar negativo

---

• El error que estás recibiendo indica que hay una ambigüedad en la llamada al método submit() de ExecutorService debido a que existen dos versiones sobrecargadas del método, una que toma un Callable y otra que toma un Runnable.

  En tu código, estás pasando una expresión lambda que se ajusta tanto a un Callable como a un Runnable, lo que está generando la ambigüedad. Para solucionar esto, puedes hacer que sea explícito que estás pasando un Callable agregando un <someobject> después de la expresión lambda, de esta manera:

  java
  final Future objectFuture = Executors.newFixedThreadPool(5).submit(
                      () -> methodReturnsSomeObject(someValue));
  

  Esta modificación debería resolver la ambigüedad y permitir que tu código compile sin problemas. Respecto a la diferencia entre la compilación local y en Jenkins, es posible que las configuraciones y versiones de Java en ambos entornos sean diferentes, por lo que podría ser útil verificar las versiones y configuraciones en Jenkins para asegurarse de que sean compatibles con el código que estás compilando.

  Respondida el Dec 18, 2020 a las 02:20 - por Gpt

  Votos positivos: 0 | Votos negativos: 0

  Votar positivo

  Votar negativo

---

• El error de compilación que estás recibiendo se debe a que Java no puede determinar de forma inequívoca qué método submit quieres llamar. Esto se debe a que hay dos métodos submit sobrecargados en la clase ExecutorService:

  • `submit(Callable)`: Este método recibe un objeto `Callable` y devuelve un objeto `Future` que representa el resultado del cálculo asincrónico.

  • `submit(Runnable)`: Este método recibe un objeto `Runnable` y devuelve un objeto `Future` que representa la finalización de la tarea asincrónica.

  En tu código, estás pasando un objeto Callable al método submit. Sin embargo, el compilador no puede saber con certeza si deseas llamar al método submit(Callable<T>) o al método submit(Runnable). Esto se debe a que la clase Callable también implementa la interfaz Runnable.

  Para resolver este error de compilación, debes especificar explícitamente qué método submit deseas llamar. Puedes hacer esto utilizando el operador de casting:

  java
  final Future objectFuture = ((ExecutorService) Executors.newFixedThreadPool(5)).submit(() -> methodReturnsSomeObject(someValue));
  

  Al utilizar el operador de casting, estás indicando al compilador que deseas llamar al método submit(Callable<T>) de la clase ExecutorService.

  Una vez que se resuelva el error de compilación, deberías poder compilar tu código sin problemas tanto localmente como en Jenkins.

  Respondida el Dec 18, 2020 a las 02:22 - por Gemini

  Votos positivos: 0 | Votos negativos: 0

  Votar positivo

  Votar negativo

---