Threads: Lokal definierte variable in einem einschließenden Bereich muss endgültig sein, oder effektiv final

Habe ich meine main-Klasse ausgeführt, in den main Methode. Es läuft ein Prozess, der potenziell braucht eine Menge Zeit in Anspruch, so habe ich eine andere Methode verhindern, dass der Prozess: es wirft einfach ein flag, das macht den ganzen Prozess zu stoppen:

public void stopResolutionProcess() {
    stop = true;
}

Dieser ist der call, der ausgeführt wird, den großen Prozess:

boolean solutionFound = tournament.solve();

So, bevor es richtig, ich brauche zu laufen, einen sekundären thread zu nennen stopResolutionProcess():

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Stop resolution process? (Y/N): ");
        String answer = sc.next();
        if (answer.equalsIgnoreCase("y")) {
            tournament.getSolver().stopResolutionProcess(); //error here
        }
    }
});

Aber ich erhalte eine Fehlermeldung in der letzten Zeile. Es sagt:

Lokale variable Turnier definiert, in einer umschließenden scope muss endgültig sein
oder effektiv final

Welchen Ansatz sollte ich nehmen um dieses problem zu lösen, um die Methode zu testen, dass der Prozess beendet?

Wie der Fehler schon sagt, Sie sollte es final oder kopieren Sie den Wert in eine variable, die endgültig ist.
"Lokale variable tournament definiert, die in einem umschließenden scope muss endgültig sein, oder effektiv final" Also, die tournament Deklaration von Variablen wäre eine offensichtliche Sache zu gehören, in Frage.

InformationsquelleAutor dabadaba | 2016-04-10

2

Ihre Frage selbst ist die Antwort auf das, was Sie gefragt haben.

Lokale variable Turnier definiert, in einer umschließenden scope muss endgültig sein, oder effektiv final

Wenn die anonyme Klasse innerhalb einer Methode werden alle lokalen Variablen in der Methode, aber außerhalb des Körpers der anonymen Klasse gemacht werden sollte, endgültig in den Fall, Sie werden benötigt, um verwendet werden, in die anonyme Klasse.
```
public class OuterClass{
    int x,y;
    public void someMethod(){

         final int neededByAnonymousClass = x + y + 30;

         Runnable runnable = new Runnable(){
              //This is like we are creating a class which simply implements Runnable interface.
              //Scope of this class is inside the method someMethod()
              //run() method may be executed sometime later after the execution of someMethod() has completed.
             //all the local variables needs to be final in order they can be used later in time when run() gets executed.

             public void run(){
                 System.out.println(neededByAnonymousClass+ 40);
             }
         }
         Thread thread = new Thread(runnable); //passing the object of anonymous class, created above
         thread.start();
    }
}
```
Also nur machen Sie Ihre alle lokalen Variablen (defiend innerhalb des Bereichs einer Methode) als Finale, die Sie verwenden möchten, innerhalb der run() Methode des lokalen anonymen Klasse (Klasse ohne Namen). In Fall, dass Sie möchten, ändern Sie den Wert einer Variablen dann die änderungen zuerst und dann das erstellen der anonymen Klasse. Erstellen Sie eine weitere final-variable und initialisieren Sie es mit dem geänderten Wert und verwenden die gleichen in der anonymen Klasse.

Ich zitiere nachfolgend aus der Antwort auf eine andere Frage im Zusammenhang : Lokale variable deklariert werden muss-Finale

Es ist ein Versprechen an sich selbst (und dem compiler), dass der Wert der box
wird sich nicht ändern in den umschließenden scope. Der compiler wird Ihnen sagen, wenn Sie
brechen Sie dieses Versprechen.

Den Wert der Variablen wird verwendet, einige Zeit später, nachdem die Ausführung der Methode abgeschlossen ist. Daher lokale Variablen als final deklariert. Die Methoden in der anonymen Objekt nicht ausgeführt, in der Reihenfolge, wie Sie geschrieben werden (sequentiell)

Nehme an folgenden Zeilen von code, wo wir haben eine Methode : methodA () " und enthält die definition einer anonymen Klasse.

[ Zeile-1 : Methode A, Zeile-2 Methode A, Zeile-3 : anonyme Klasse , Line
4 Methode der anonymen Klasse, die Linie 5 der Methode A ] ==> die Reihenfolge der Ausführung

Zeile 1, Zeile 2, Zeile 3 (nur die Objekt-Erstellung der anonymen Klasse), Linie 5. Zeile 4 wird ausgeführt, später, wenn die Methode auf das Objekt der anonymen Klasse wird aufgerufen.

InformationsquelleAutor nits.kk

Also was ist das problem.. ein kleines Beispiel

String myString = new String("MyString");
Thread thr = new Thread() {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(myString);
        }
    }
}
thr.start();
myString = new String("AnotherString");

Also welche Ausgabe würden Sie erwarten hier? So etwas wie:

MyString
MyString
AnotherString
AnotherString
AnotherString

Das problem ist, dass Sie nicht wissen, Wann die myString variable geändert wird. Dies konnte geschehen, nachdem es gedruckt wurde 0 mal, nachdem Sie gedruckt werden 5-mal oder jederzeit in-between. Oder in anderen Worten, dies ist nicht vorhersehbar und ist sehr unwahrscheinlich werden sollen.

Um ein definiertes Verhalten, die variable, die Sie verwenden, in den Thread muss endgültig sein:

final String myString = new String("MyString");
Thread thr = new Thread() {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(myString);
        }
    }
}
thr.start();
//now this following line is not valid anymore and will lead to a compile error
myString = new String("AnotherString");

Nun wir haben ein definiertes Verhalten, und wir wissen, dass der Ausgang sein wird:

MyString
MyString
MyString
MyString
MyString

Eine gute Antwort, ich Frage mich, wer down-stimmten Sie zunächst...

InformationsquelleAutor MalaKa

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.