una - ¿Puedo pasar un Método como parámetro de otro método en Java?

sentencia return java

Question

Estoy tratando de medir el tiempo de ejecución para varios métodos. así que estaba pensando en hacer un método en lugar de duplicar el mismo código muchas veces.

Aquí está mi código:

private void MeasureExecutionTime(Method m)
{
startTime = System.nanoTime();
try
{
m();
}
finally
{
endTime = System.nanoTime();
}
elapsedTime = endTime - startTime;
System.out.println("This takes " + elapsedTime + " ns.");
}

Supongamos que tengo myMethod() , ¿cómo puedo usar MeasureExecutionTime() para medir el tiempo de ejecución de myMethod ?

Answer 1

Estás en la ruta correcta, necesitas pasar el objeto Método, el objeto objetivo en el que ejecutar el método y los argumentos que toma y luego invocarlo en tu captura de prueba, algo como:

private void MeasureExecutionTime(Method m, Object target, Object args)
throws IllegalArgumentException,
IllegalAccessException,
InvocationTargetException
{
long startTime = System.nanoTime();
long endTime;
try
{
m.invoke(target, args);
}
finally
{
endTime = System.nanoTime();
}
long elapsedTime = endTime - startTime;
System.out.println("This takes " + elapsedTime + " ns.");
}

Answer 2

Estoy de acuerdo con @hvgotcodes, pero sí, es posible, aunque no lo llames m() , sino que usas invoke (lo que significa que probablemente deberías pasar otro argumento o dos con él ...).

Answer 3

Los métodos no son objetos de primera clase en Java, por lo que no se pueden pasar como parámetros. Podría usar wrap your method call en una clase anómala que se extiende, por ejemplo, la interfaz Runnable :

private void MeasureExecutionTime(Runnable r) {
r.run();
}
...
MeasureExecutionTime(new Runnable() { public void run() { m(); } });

Answer 4

Tengo un contador de llamadas a objetos que básicamente se ve así:

private long count;
private long errors;
private long duration;
private long errorDuration;

Con dos métodos de "tiempo" para cronometrar métodos que devuelven algo y otros métodos que son nulos.

public <T> T time(ReturningRunnable<T> runnable) {
long start = currentTimeMillis();
T result = null;
try {
result = runnable.run();
} catch (Throwable ex) {
errorDuration += currentTimeMillis() - start;
errors++;
throw runtime(ex);
}
duration += currentTimeMillis() - start;
count++;
return result;
}
public void time(Runnable runnable) {
time(new RunnableRunner(runnable));
}

Elegí volver a plantear las excepciones como excepciones de tiempo de ejecución (ya que no soy partidario de las excepciones comprobadas), pero también podría hacer que su interfaz personalizada MyRunnable arroje excepciones y simplemente atraparlas y volver a lanzarlas. Aquí hay un uso de lo anterior:

counter.time(new Runnable() {
@Override
public void run() {
// Do something
});

O esto, en el caso del valor de retorno:

return counter.time(new ReturningRunnable<Integer>() {
@Override
public Integer run() {
return 1; // You get the idea
});

Me gusta esto porque mis objetos mostradores pueden exponerse sobre JMX e inyectarse donde los necesite. Podrías hacer lo que pediste con reflexión, pero creo que sería complicado (en mi humilde opinión).

Answer 5

la forma más sencilla de hacerlo es pasar una interfaz. Así que algo así como

public interface CommonFuncs {
public void execute();
... more functions
}

y luego puedes tener métodos que toman CommonFuncs como argumento. Las implementaciones de esos métodos pueden llamar al método de execute .

Answer 6

puedes hacer algo como:

private void MeasureExecutionTime(Method m)
{
startTime = System.nanoTime();
try
{
m.invoke(classObj, args);
}
finally
{
int endTime = System.nanoTime();
}
elapsedTime = endTime - startTime;
System.out.println("This takes " + elapsedTime + " ns.");
}