JavaFX使线程等待并且threadave gui更新

Question

So I had something like this:

public class test {
    final ProgressBar bar = new ProgressBar(0.0);
    final int result;
    final worker work = new worker();

// GUI Scene change happens here

    new Thread(() -> {
        result = work.doSomething(this.bar);
    }).start();
}

public class worker{
    public int doSomething(ProgressBar bar){
        for(int i = 1; i <= 1000000; i++)
            Platform.runLater(() -> { bar.setProgress(i/100000.0); });
        return 51;
    }
}

And everything worked fine, until I had to wait for something else to finish before I could continiue after the runnable so I altered it like this:

public class test {
    final ProgressBar bar = new ProgressBar(0.0);
    TextArea area = new TextArea();
    int result;
    final worker work = new worker();
    final worker work2 = new worker2();
    final CountDownLatch latch1 = new CountDownLatch(1);

// GUI Scene change happens here

    new Thread(() -> {
        result = work.doSomething(this.bar);
        latch1.CountDown();
    }).start();

    latch1.await();

    new Thread(() -> {
        work2.doSomething(result, area);
    }).start();
}

public class worker{
    public int doSomething(ProgressBar bar){
        for(int i = 1; i <= 1000000; i++)
            Platform.runLater(() -> { bar.setProgress(i/100000.0); });
        return 51;
    }
}

public class worker2{
    ArrayList<String> list = new ArrayList<>();

    public int doSomething(int index, TextArea area){
            Platform.runLater(() -> { area.append(list.get(index)); });
    }
}

later I do something like this:

    public class test {
    final ProgressBar bar = new ProgressBar(0.0);
    TextArea area = new TextArea();
    int result;
    final worker work = new worker();
    final worker2 work2 = new worker2();
    final worker3 work3 = new worker3();
    final CountDownLatch latch1 = new CountDownLatch(1);
    final CountDownLatch latch2 = new CountDownLatch(Map.keySet().size());

    // This already has values
    // it is not really a file array list in the map, but it is easier to show it this way
    Map<String, ArrayList<File>> mapTypes; 

// GUI Scene change happens here

    new Thread(() -> {
        result = work.doSomething(this.bar);
        latch1.CountDown();
    }).start();

    latch1.await();

    new Thread(() -> {
        work2.doSomething(result, area);
    }).start();

    // Even thought I don't use it here I need a for each on the keyset
    mapTypes.keySet().forEach((String s) -> {
        new Thread(() -> {
            // Here I actually load classes with a reflection
            work3.doSomething(mapTypes.get(s), area);
            latch2.CountDown();
        }).start();
    }
    latch2.await();
    System.out.println("Done");
}

public class worker{
    public int doSomething(ProgressBar bar){
        for(int i = 1; i <= 1000000; i++)
            Platform.runLater(() -> { bar.setProgress(i/100000.0); });
        return 51;
    }
}

public class worker2{
    ArrayList<String> list = new ArrayList<>();

    public int doSomething(int index, TextArea area){
            Platform.runLater(() -> { area.append(list.get(index)); });
    }
}

public class worker3{
    public int doSomething(Arraylist<File> files, TextArea area){
        for (File f : files)
            Platform.runLater(() -> { area.append(f.getName()); });
    }
}

Now my gui started to lag when switching scenes - meaning - the whole thread1 processed itself and then the gui loaded everything. After researching a bit I think this happens because the main thread is handeling the runLater "requests" and because of the await() the main thread has to wait until the first secondary thread comes to the CountDown() .

My question is, how do I manage that the main thread isn't starting the second background thread before the first one finished? Bonus question: what would be a more efficient way to update my GUI instead of Plattform.runlater() ?

Note:
I have also looked at this Question but it does not fully address my Problem as I do not need to queue threads. I much more need to know how to make the main thread wait until the sub thread is finished and only then proceeds. The main thread, however, must not be completly inactive but manage the incoming update request.

Thank you in advance

Technologies used: - NetBeans
- JavaFX ( No FXML - everything designed in the code)
- CSS
- Java ( Obviously )
- Windows 10 pro

Answer 1

The (main) problem with your code is that you are calling latch.await() , which is a blocking method, on the JavaFX Application Thread. Since the JavaFX Application Thread is responsible for updating the UI, this prevents the UI from being redrawn until latch.await() releases.

The basic premise of your question is wrong: you never want to make the UI thread pause, as it will always render the UI unresponsive and prevent any updates. Instead, you should think in terms of "performing a unit of work" in the background, potentially with updates to the UI as it proceeds, and then doing something in response to the background work completing.

Another potential issue with your code is that you are submitting a vast number of Runnable s to the FX Application Thread via Platform.runLater() . You probably need to throttle these so that they don't "flood" the FX Application Thread.

You can solve all these issues using the Task API . The Task class is an implementation of Runnable whose call() method is invoked from the run() method. It has various updateXXX methods, including updateProgress() , that update various properties on the FX Application thread, and throttle these calls so that no more are scheduled than the FX Application thread can handle. Finally, it has callback methods, such as setOnSucceeded() that are invoked on the FX Application Thread when the background work completes (or, generally, when the task changes its lifecycle state).

(Note: I renamed your classes so they conform to recommended naming conventions. Like most Java developers, I find it extremely difficult to read code that doesn't conform to these.)

public class Test {
    final ProgressBar bar = new ProgressBar(0.0);
    TextArea area = new TextArea();
    int result;
    final Worker work = new Worker();
    final Worker2 work2 = new Worker2();

// GUI Scene change happens here

    work.setOnSucceeded(e -> work2.doSomething(work.getValue(), area));
    bar.progressProperty().bind(work.progressProperty());
    new Thread(work).start();

}

public class Worker extends Task<Integer> {
    @Override
    protected Integer call(){
        for(int i = 1; i <= 1000000; i++)
            updateProgress(i, 1000000); 
        return 51;
    }
}

public class Worker2{
    ArrayList<String> list = new ArrayList<>();

    // this is now executed on the FX Application Thread: there is no need 
    // for Platform.runLater():

    public int doSomething(int index, TextArea area){
            area.append(list.get(index)); 
    }
}

---

Your second example is a little more complicated, and I'm not really sure you need the additional threads at all: the only thing your Worker3 seems to do is append a line to a text area, which has to be done on the FX Application Thread anyway. But in case your real application would need background work for each file, this is what it would look like. I would recommend using a task pool for this instead of creating so many tasks by hand. This would look something like:

public class Test {

    final ProgressBar bar = new ProgressBar(0.0);
    TextArea area = new TextArea();
    int result;
    final Worker work = new Worker();
    final Worker2 work2 = new Worker2();

    final ExecutorService exec = Executors.newCachedThreadPool();

    // This already has values
    // it is not really a file array list in the map, but it is easier to show it this way
    Map<String, ArrayList<File>> mapTypes; 

// GUI Scene change happens here

    work.setOnSucceeded(e -> {
        work2.doSomething(work.getValue(), area);

        Task<Void> processAllFiles = new Task<Void>() {
            @Override
            protected Void call() throws Exception {
                final CountDownLatch latch2 = new CountDownLatch(Map.keySet().size());
                mapTypes.keySet().forEach((String s) -> {
                    exec.submit(() -> {
                        work3.doSomething(mapTypes.get(s), area);
                        latch2.CountDown();
                    });
                });
                latch2.await();
                return null ;
            }
        };

        processAllFiles.setOnSucceeded(evt -> {
            // executed on fx application thread:
            System.out.println("Done");
        });
    });

    bar.progressProperty().bind(work.progressProperty());
    exec.submit(work);
}