Может ли Lambda выражение хранить состояние?

Lambda выражения и состояние: функциональное программирование vs состояние

Краткий ответ

Lambda выражение БЕЗ состояния в классическом смысле, но может захватывать и использовать состояние из окружающего контекста (через замыкания). Нельзя хранить новое состояние внутри самой lambda.

Функциональная природа Lambda

// Lambda БЕЗ состояния: чистая функция
Function<Integer, Integer> square = x -> x * x;
// Результат зависит ТОЛЬКО от входного параметра
System.out.println(square.apply(5));  // 25
System.out.println(square.apply(5));  // 25 (детерминировано)

Захват переменных из контекста

Lambda МОЖЕТ "захватить" переменные из окружающей области видимости:

1. Захват значений (Value Capture)

public void captureValue() {
    int x = 10;  // локальная переменная
    
    Runnable r = () -> System.out.println(x);  // Lambda захватила x
    r.run();  // Выведет: 10
}

Ограничение: переменная должна быть effectively final

public void wrongCapture() {
    int x = 10;
    
    Runnable r = () -> System.out.println(x);  // OK, x не меняется
    
    x = 20;  // ОШИБКА! Lambda ожидает effectively final
    r.run();
}

// Исправить:
final int x = 10;
Runnable r = () -> System.out.println(x);  // OK

Почему effectively final?

• Lambda скомпилирует в private метод
• Переменная копируется в параметр метода
• Если переменная может измениться, возникнет race condition

2. Захват this (Reference Capture)

public class Counter {
    private int count = 0;
    
    public Consumer<String> createIncrementor() {
        return msg -> {
            count++;  // Захватил this.count
            System.out.println(msg + ": " + count);
        };
    }
}

Counter counter = new Counter();
Consumer<String> action = counter.createIncrementor();
action.accept("Call 1");  // "Call 1: 1"
action.accept("Call 2");  // "Call 2: 2"
// Lambda имеет доступ к состоянию объекта!

Важно: это НЕ состояние самой lambda, а состояние объекта, к которому lambda имеет доступ.

Lambda СОБСТВЕННО состояние НЕ хранит

// Если попытаться добавить поле в lambda:
Function<Integer, Integer> fn = new Function<Integer, Integer>() {
    private int state = 0;  // Lambda может иметь состояние
    
    @Override
    public Integer apply(Integer x) {
        state++;  // Изменяет состояние
        return x + state;
    }
};

// Но это уже не lambda, это анонимный класс!

Lambda выражение — это синтаксический сахар для функционального интерфейса:

// Это:
Function<Integer, Integer> fn = x -> x * 2;

// Компилируется в что-то вроде:
private static Integer lambda$0(Integer x) {
    return x * 2;  // Чистая функция, без состояния
}

// Создаёт функциональный интерфейс, который вызывает метод
Function<Integer, Integer> fn = Factory::lambda$0;

Практические примеры

Пример 1: Stateless Lambda (рекомендуется)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// Чистая функция: без побочных эффектов
List<Integer> squared = numbers.stream()
    .map(x -> x * x)  // Stateless
    .collect(Collectors.toList());

Пример 2: Lambda с захватом (осторожно!)

public List<Integer> filterByThreshold(List<Integer> numbers) {
    int threshold = 10;  // effectively final
    
    return numbers.stream()
        .filter(x -> x > threshold)  // Захватила threshold
        .collect(Collectors.toList());
}

Пример 3: Lambda с доступом к объекту (Reference Capture)

public class Logger {
    private List<String> logs = new ArrayList<>();
    
    public Consumer<String> createLogger() {
        return msg -> {
            // Захватила this, обращается к logs
            logs.add(msg);
            System.out.println("Logged: " + msg);
        };
    }
    
    public List<String> getLogs() { return logs; }
}

Logger logger = new Logger();
Consumer<String> log = logger.createLogger();
log.accept("Event 1");  // Добавляет в this.logs
log.accept("Event 2");
System.out.println(logger.getLogs());  // [Event 1, Event 2]

Пример 4: Неправильно — попытка изменить захваченную переменную

public void wrong() {
    int[] counter = {0};  // Обходит "effectively final"
    
    Runnable r = () -> {
        counter[0]++;  // Изменяет содержимое массива
        System.out.println(counter[0]);
    };
    
    r.run();  // 1
    r.run();  // 2
    r.run();  // 3
}

// Это РАБОТАЕТ, но это плохой паттерн:
// - Сложно читать
// - Непредсказуемо при параллелизме
// - Нарушает функциональный стиль

Состояние vs замыкание (Closure)

Замыкание (Closure):

• Lambda, которая "помнит" переменные из окружающей области
• ЧИТАЕТ значения, но НЕ ИЗМЕНЯЕТ их
• Ссылается на effectively final переменные

int multiplier = 2;
Function<Integer, Integer> multiply = x -> x * multiplier;
// Это замыкание: помнит multiplier = 2

Состояние (Stateful closure):

• Lambda, которая ХРАНИТ и ИЗМЕНЯЕТ данные
• Это уже не lambda, а объект с методом
• Нарушает функциональный стиль

Thread-safety и состояние

public class Counter {
    private int count = 0;  // Статус: SHARED
    
    public Consumer<String> createIncrementor() {
        return msg -> {
            // ОПАСНО при многопоточности!
            count++;  // Race condition
            System.out.println(msg + ": " + count);
        };
    }
}

// Если запустить из разных потоков:
ExecutorService executor = Executors.newFixedThreadPool(2);
Counter counter = new Counter();
Consumer<String> action = counter.createIncrementor();

executor.submit(() -> action.accept("Thread 1"));
executor.submit(() -> action.accept("Thread 2"));
// Результат непредсказуем: count может быть 1 или 2

// Исправить:
public Consumer<String> createIncrementor() {
    return msg -> {
        synchronized (this) {  // Или использовать AtomicInteger
            count++;
            System.out.println(msg + ": " + count);
        }
    };
}

Best Practices

1. Предпочитай Stateless Lambda

// ХОРОШО: чистая функция
Function<Integer, Integer> square = x -> x * x;
Function<Integer, Integer> add = (x, y) -> x + y;

2. Используй захват только для truly constant значений

// ХОРОШО: константа
final int TAX_RATE = 10;
Function<Integer, Integer> addTax = price -> price + (price * TAX_RATE / 100);

// ПЛОХО: переменная, которая может измениться
int threshold = 100;  // Может измениться
Predicate<Integer> isHigh = x -> x > threshold;  // Захватила, но может быть старое значение

3. Если нужно состояние, используй объект

// Вместо stateful lambda:
int[] count = {0};
Consumer<String> log = msg -> System.out.println(++count[0] + ": " + msg);

// Используй класс:
public class Logger {
    private int count = 0;
    
    public void log(String msg) {
        System.out.println(++count + ": " + msg);
    }
}

Logger logger = new Logger();
logger.log("Event 1");
logger.log("Event 2");

4. Для параллельных потоков избегай захвата mutable состояния

// ОПАСНО:
int[] sum = {0};
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.parallelStream()
    .forEach(x -> sum[0] += x);  // Race condition!

// ПРАВИЛЬНО:
int result = numbers.parallelStream()
    .reduce(0, Integer::sum);  // Функциональный approach

Вывод

Lambda выражения НЕ могут хранить состояние в собственно lambda, потому что:

1. Lambda — это функция, не объект с полями
2. Компилируется в метод, а не класс с состоянием
3. Функциональный стиль подразумевает отсутствие побочных эффектов

ЧТО Lambda МОЖЕТ:

• Захватывать значения из окружающей области (value capture)
• Обращаться к this и его полям (reference capture)
• Использовать параметры функции

Правило большого пальца:

• Если нужно состояние → используй объект с методом
• Lambda — для чистых функций и преобразований данных
• Это делает код проще, понятнее и безопаснее в многопоточности