Pq Lambdas são tão lentas em relação a instância convencional?

Programação Java
#1

Alguém pode me dizer o processo por trás disso que torna o processamento tão lento?
Pq o mesmo não acontece com classe anônimas? Vale apena abrir mão dessa diferença pra deixar o projeto mais limpo? Não sei se o método que usei pra checar essa diferença é preciso

image
image.png1366×768 99.1 KB

pro lambda carregar leva entre 0.050 e 0.7 segundos, nas classes anônimas leva no max 0.013 segundos. Pode ser a minha máquina que é fraca.

#2

Pode postar o código completo (em texto, não imagens)? Tanto do Runnable lambda quanto do código com classes anônimas. Pois, sem ver tudo o que seu código está fazendo, é difícil tentar explicar a causa dessa diferença.

Abraço.

#3 
    package Principal;

public class MeuPrograma {

	public static void main(String[] args) throws InterruptedException {
		double inicio=System.currentTimeMillis();
		
		//Runnable r= 
			
			
		
	new Thread(()-> {	double	in=System.currentTimeMillis();
		 
			for(int i=0;i<10000;) {
				i++;	
			}
			System.out.println(((((double)System.currentTimeMillis()-in)/1000))+"segundos pra rodar o lambda");
		
	}).start();
System.out.println(((((double)System.currentTimeMillis()-inicio)/1000))+"segundos pra carregar o labda");

//		for(int i=0;i<100;) {
//			i++;
//		}
		
		

		//System.out.println(thread.getName());
	}

}

lambdas(esse está inserido direto no construtor do thread)

#4 
package Principal;

public class MeuPrograma {

	public static void main(String[] args) throws InterruptedException {
		double inicio=System.currentTimeMillis();
		
		Runnable r= new Runnable(){

			@Override
			public void run() {
				// TODO Auto-generated method stub
				
			}}; 
			
			
		
//	new Thread(()-> {	double	in=System.currentTimeMillis();
//		 
//			for(int i=0;i<10000;) {
//				i++;	
//			}
//			System.out.println(((((double)System.currentTimeMillis()-in)/1000))+"segundos pra rodar o lambda");
//		
//	}).start();
System.out.println(((((double)System.currentTimeMillis()-inicio)/1000))+"segundos pra carregar o labda");

//		for(int i=0;i<100;) {
//			i++;
//		}
		
		

		//System.out.println(thread.getName());
	}

}

Classes anônimas

#5

mas no geral é só isso mesmo, ele só carrega isso. fiz alguns processos e cronometrei em cada ponto, mas onde tá a maior diferença é na hora de gera o lambda

#6

Esse código está funcional (ou seja, roda normalmente)? Se sim, tente colocá-lo no Ideone, para vermos rodando.

O método run do seu Runnable não faz nada, e o Runnable em si não é usado em parte alguma. Não diria que esses códigos são equivalentes, então comparar o tempo de cada um não parece correto.

Pode ser que exista mesmo um custo ligeiramente maior em usar lambda, pois são coisas distintas na JVM. Fiz um teste grosseiro (estou enferrujado em Java) e, apesar de haver uma diferença, não a achei tão significativa. Veja neste link: https://ideone.com/36wEdq

Abraço.

1 curtida
#7

o run não faz nada de propósito, ele precisava ser declarado por implementar Runnable. fiz o esse lambda sem método só pra ver se o tempo era alterado pra executar o método dentro do lambda, mas como pode ver só de declarar o lambda ele da esse delay.

#8

Isso mostra que nem todo código que é menor e limpinho necessariamente seja mais rápido ou até mesmo igual.

1 curtida
#9

Se rodares várias vezes (na mesma execução) irás ver que essa lentidão só ocorre na primeira vez.

1 curtida