Expresiones Lambda | Enfoque de programación concurrente 4

Requisito previo: diferentes enfoques para la programación concurrente en Java

Las expresiones lambda tienen un comportamiento muy similar al de las clases internas anónimas. Tienen acceso completo al código de las clases circundantes, incluidos los datos privados. Son mucho más concisos, sucintos y legibles . Sin embargo, las expresiones lambda no pueden tener variables de instancia, por lo que no mantienen un estado.

Podemos reemplazar Anonymous Inner Class con Lambda Expression de la siguiente manera:

Clase Interna Anónima:

    Thread thread = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("Printed inside Anonymous Inner Class!");
      }
    });

Expresión lambda:

Thread anotherThread = new Thread(() -> System.out.println(“¡Impreso dentro de Lambda!”));

Implementación práctica:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
  
// Code for Concurrent programming using
// Lambda Expression
public class MyClass {
  
    // Driver method
    public static void main(String[] args)
    {
        new MyClass().startThreads();
    }
  
    // Starting threads with pool size as 2
    private void startThreads()
    {
        ExecutorService taskList
            = Executors.newFixedThreadPool(2);
  
        for (int i = 0; i < 5; i++) {
  
            int finalI = i + 1;
  
            // Prints thread name and value
            // of the counter variable
            taskList.execute(() -> {
  
                for (int j = 0; j < finalI; j++) {
  
                    System.out.println(
                        Thread
                            .currentThread()
                            .getName()
                        + " Counter:" + j);
                    pause(Math.random());
                }
            });
        }
        taskList.shutdown();
    }
  
    // Pauses execution allowing time for
    // system to switch back and forth
    private void pause(double seconds)
    {
        try {
            Thread.sleep(
                Math.round(1000.0 * seconds));
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Producción:

pool-1-thread-1 Counter:0
pool-1-thread-2 Counter:0
pool-1-thread-2 Counter:1
pool-1-thread-2 Counter:0
pool-1-thread-1 Counter:0
pool-1-thread-2 Counter:1
pool-1-thread-1 Counter:1
pool-1-thread-2 Counter:2
pool-1-thread-1 Counter:2
pool-1-thread-2 Counter:0
pool-1-thread-1 Counter:3
pool-1-thread-2 Counter:1
pool-1-thread-2 Counter:2
pool-1-thread-2 Counter:3
pool-1-thread-2 Counter:4

Ventajas: el usuario puede acceder fácilmente a los datos de la clase principal, incluidos los datos privados. Las lambdas son concisas, sucintas y legibles.

Desventajas: las Lambdas no pueden tener variables de instancia, por lo que no podemos pasar argumentos al método de ejecución. Además, normalmente usamos lambdas cuando tenemos algunos datos compartidos que invitan al peligro de las condiciones de carrera.