Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Przechwytywanie efektywnie finalnych zmiennych lokalnych

Lambda może przechwycić zmienną lokalną bez modyfikatora `final`, jeśli jest ona efektywnie finalna. Stała referencja nie oznacza jednak, że wskazywany obiekt jest niemutowalny.

Wersja: Java SE 21

Składnia

Java SE 21: a lambda expression or an inner class can use an enclosing local variable or parameter only if it is final or effectively final. A captured local variable must also be definitely assigned before the lambda or inner-class body. For example: String prefix = "task "; Runnable task = () -> System.out.println(prefix);

W Java SE 21 lambda lub klasa wewnętrzna, w tym lokalna lub anonimowa, może użyć zmiennej lokalnej albo parametru z otaczającego zakresu tylko wtedy, gdy jest on final lub efektywnie finalny. Zmienna lokalna musi też mieć na pewno przypisaną wartość przed ciałem lambdy lub klasy wewnętrznej. Przechwytywana jest wartość, a nie miejsce do zapisu; lambda może użyć tej wartości nawet po zakończeniu metody, w której powstała.

Zmienna lokalna zadeklarowana z inicjalizatorem, ale bez final, jest efektywnie finalna, jeśli nigdzie nie występuje po lewej stronie operatora przypisania ani jako operand ++ lub --. Dotyczy to także przypisań wewnątrz inicjalizatora: deklaracja int x = (x = 1); jest poprawna, ale x nie jest efektywnie finalna. Parametry traktuje się jak zmienne zainicjalizowane. Nawet x = x lub x += 0 odbiera ten status, także po utworzeniu lambdy; próba przechwycenia powoduje błąd kompilacji. Zmienna lokalna zadeklarowana bez final i bez inicjalizatora może otrzymać wartość w alternatywnych gałęziach i pozostać efektywnie finalna, jeśli przy każdym przypisaniu, po obliczeniu prawego operandu, jest zarówno na pewno nieprzypisana, jak i nie jest na pewno przypisana, oraz nigdy nie jest operandem ++ ani --. Przed przechwyceniem musi mieć na pewno przypisaną wartość.

Nie można przechwycić i ze zwykłej pętli for, jeśli aktualizuje je i++. Utwórz kopię final int id = i; wewnątrz pętli. Rozszerzona pętla for ma osobną zmienną dla każdej iteracji; można ją przechwycić, jeśli pozostaje final lub efektywnie finalna.

Dla typu referencyjnego przechwytywana jest referencja, a nie kopia obiektu. ++acc[0] zmienia element tablicy bez zmiany acc. Pola obiektu, również pola współdzielone static, podlegają własnym regułom, a nie regule przechwytywania zmiennych lokalnych. final nie zapewnia bezpieczeństwa wątkowego: współdzielony stan mutowalny wymaga odpowiedniej koordynacji, np. ochrony wszystkich dostępów do danego stanu tą samą blokadą.

Przykłady

public class CaptureDemo {
    static Runnable[] makeTasks() {
        String prefix = "task ";
        final int[] acc = {0};
        Runnable[] tasks = new Runnable[2];

        for (int i = 0; i < tasks.length; i++) {
            final int id = i;
            tasks[i] = () -> System.out.println(prefix + id + ": " + ++acc[0]);
        }
        return tasks;
    }

    public static void main(String[] args) {
        Runnable[] tasks = makeTasks();
        tasks[0].run();
        tasks[1].run();
    }
}

Wynik

task 0: 1
task 1: 2

`prefix` jest efektywnie finalna, a `id` i `acc` są jawnie `final`. Po powrocie z `makeTasks()` każde zadanie używa własnego `id`, ale oba zwiększają ten sam element `acc[0]`. Zadania wykonują się kolejno w jednym wątku.

Powiązane lekcje

  • Java · Lekcja 22 · Zaawansowany · Wersja: 2
  • Java · Lekcja 34 · Zaawansowany · Wersja: 2
  • Java · Lekcja 36 · Zaawansowany · Wersja: 2
  • Java · Lekcja 8 · Średniozaawansowany · Wersja: 2

Źródła