Jcfg.J Jcfg.J - 3 months ago 14
Java Question

Boolean wont Update from Object.getBoolean();

Pretty much, I'm trying to write a simple program that lets the user choose a file. Unfortunately, JFileChooser through Swing is a little outdated, so I am trying to use JavaFX FileChooser for this. The goal is to run FileGetter as a thread, transfer the file data to the Main Class, and continue from there.

Main Class:

package application;
import java.io.File;
import javafx.application.Application;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.layout.BorderPane;


public class Main {

public static void main(String[] args) {
Thread t1 = new Thread(new FileGetter());
FileGetter fg = new FileGetter();
t1.start();
boolean isReady = false;
while(isReady == false){
isReady = FileGetter.getIsReady();
}
File file = FileGetter.getFile();

System.out.println(file.getAbsolutePath());
...

}
}


FileGetter Class:

package application;

import java.io.File;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.stage.FileChooser;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.layout.BorderPane;


public class FileGetter extends Application implements Runnable {

static File file;
static boolean isReady = false;


@Override
public void start(Stage primaryStage) {
try {

FileChooser fc = new FileChooser();
while(file == null){
file = fc.showOpenDialog(primaryStage);
}
isReady = true;
Platform.exit();
} catch(Exception e) {
e.printStackTrace();
}
}
@Override
public void run() {
launch();
}

public static boolean getIsReady(){
return isReady;
}

public static File getFile(){
return file;
}

}


Problem is that the value of isReady in the while loop doesn't update to true when the user picked a file (the reason I have it is to prevent the code in Main from continuing with a File set to null).

Any help, alternative suggestions, or explanations as of why this happens is very much appreciated!

Answer

The easiest way to implement this

Instead of trying to drive the horse with the cart, why not just follow the standard JavaFX lifecycle? In other words, make your Main class a subclass of Application, get the file in the start() method, and then proceed (in a background thread) with the rest of the application?

public class Main extends Application {

    @Override
    public void init() {
        // make sure we don't exit when file chooser is closed...
        Platform.setImplicitExit(false);
    }

    @Override
    public void start(Stage primaryStage) {
        File file = null ;
        FileChooser fc = new FileChooser();
        while(file == null){
            file = fc.showOpenDialog(primaryStage);
        }
        final File theFile = file ;
        new Thread(() -> runApplication(theFile)).start();
    }

    private void runApplication(File file) {
        // run your application here...
    }

}

What is wrong with your code

If you really want the Main class to be separate from the JavaFX Application class (which doesn't really make sense: once you have decided to use a JavaFX FileChooser, you have decided you are writing a JavaFX application, so the startup class should be a subclass of Application), then it gets a bit tricky. There are several issues with your code as it stands, some of which are addressed in other answers. The main issue, as shown in Fabian's answer, is that you are referencing FileGetter.isReady from multiple threads without ensuring liveness. This is exactly the issue addressed in Josh Bloch's Effective Java (Item 66 in the 2nd edition).

Another issue with your code is that you won't be able to use the FileGetter more than once (you can't call launch() more than once), which might not be an issue in your code now, but almost certainly will be at some point with this application as development progresses. The problem is that you have mixed two issues: starting the FX toolkit, and retrieving a File from a FileChooser. The first thing must only be done once; the second should be written to be reusable.

And finally your loop

while(isReady == false){
    isReady = FileGetter.getIsReady();      
}

is very bad practice: it checks the isReady flag as fast as it possibly can. Under some (fairly unusual) circumstances, it could even prevent the FX Application thread from having any resources to run. This should just block until the file is ready.


How to fix without making Main a JavaFX Application

So, again only if you have a really pressing need to do so, I would first create a class that just has the responsibility of starting the FX toolkit. Something like:

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;

import javafx.application.Application;
import javafx.application.Platform;
import javafx.stage.Stage;

public class FXStarter extends Application {

    private static final AtomicBoolean startRequested = new AtomicBoolean(false);
    private static final CountDownLatch latch = new CountDownLatch(1);

    @Override
    public void init() {
        Platform.setImplicitExit(false);
    }

    @Override
    public void start(Stage primaryStage) {
        latch.countDown();
    }

    /** Starts the FX toolkit, if not already started via this method,
     ** and blocks execution until it is running.
     **/
    public static void startFXIfNeeded() throws InterruptedException {
        if (! startRequested.getAndSet(true)) {
            new Thread(Application::launch).start();
        }
        latch.await();
    }
}

Now create a class that gets a file for you. This should ensure the FX toolkit is running, using the previous class. This implementation allows you to call getFile() from any thread:

import java.io.File;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

import javafx.application.Platform;
import javafx.stage.FileChooser;


public class FileGetter {

    /**
     ** Retrieves a file from a JavaFX File chooser. This method can 
     ** be called from any thread, and will block until the user chooses
     ** a file.
     **/

    public File getFile() throws InterruptedException {

        FXStarter.startFXIfNeeded() ;

        if (Platform.isFxApplicationThread()) {
            return doGetFile();
        } else {
            FutureTask<File> task = new FutureTask<File>(this::doGetFile);
            Platform.runLater(task);
            try {
                return task.get();
            } catch (ExecutionException exc) {
                throw new RuntimeException(exc);
            }
        }
    }

    private File doGetFile() {
        File file = null ;
        FileChooser chooser = new FileChooser() ;

        while (file == null) {
            file = chooser.showOpenDialog(null) ;
        }

        return file ;
    }
}

and finally your Main is just

import java.io.File;

public class Main {

    public static void main(String[] args) throws InterruptedException {
        File file = new FileGetter().getFile();
        // proceed...
    }
}

Again, this is pretty complex; I see no reason not to simply use the standard FX Application lifecycle for this, as in the very first code block in the answer.

Comments