javafx
थ्रेडिंग

Platform.runLater का उपयोग करके यूआई को अपडेट करना

लंबे समय से चल रहे संचालन को JavaFX एप्लिकेशन थ्रेड पर नहीं चलाया जाना चाहिए, क्योंकि यह JavaFX को UI अपडेट करने से रोकता है, जिसके परिणामस्वरूप जमे हुए UI हैं।

इसके अलावा एक Node लिए कोई भी परिवर्तन जो "लाइव" दृश्य ग्राफ का हिस्सा है, उसे JavaFX एप्लिकेशन थ्रेड पर होना चाहिए । Platform.runLater का उपयोग JavaFX एप्लिकेशन थ्रेड पर उन अपडेट को निष्पादित करने के लिए किया जा सकता है।

निम्न उदाहरण प्रदर्शित करता है कि किसी भिन्न थ्रेड से Text Node बार-बार कैसे अपडेट किया जाए:

import javafx.application.Application;
import javafx.application.Platform;
import javafx.scene.Scene;
import javafx.scene.layout.StackPane;
import javafx.scene.text.Text;
import javafx.stage.Stage;

public class CounterApp extends Application {

    private int count = 0;
    private final Text text = new Text(Integer.toString(count));

    private void incrementCount() {
        count++;
        text.setText(Integer.toString(count));
    }

    @Override
    public void start(Stage primaryStage) {
        StackPane root = new StackPane();
        root.getChildren().add(text);

        Scene scene = new Scene(root, 200, 200);

        // longrunning operation runs on different thread
        Thread thread = new Thread(new Runnable() {

            @Override
            public void run() {
                Runnable updater = new Runnable() {

                    @Override
                    public void run() {
                        incrementCount();
                    }
                };

                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ex) {
                    }

                    // UI update is run on the Application thread
                    Platform.runLater(updater);
                }
            }

        });
        // don't let thread prevent JVM shutdown
        thread.setDaemon(true);
        thread.start();

        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }

}

UI अपडेट करना

निम्न कोड बटन क्लिक करने के बाद थोड़ी देर के लिए UI को गैर-जिम्मेदार बनाता है, क्योंकि बहुत सारे Platform.runLater कॉल का उपयोग किया जाता है। (बटन क्लिक करने के तुरंत बाद ListView स्क्रॉल करने का प्रयास करें।)

@Override
public void start(Stage primaryStage) {
    ObservableList<Integer> data = FXCollections.observableArrayList();
    ListView<Integer> listView = new ListView<>(data);
    
    Button btn = new Button("Say 'Hello World'");
    btn.setOnAction((ActionEvent event) -> {
        new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                final int index = i;
                Platform.runLater(() -> data.add(index));
            }
        }).start();
    });

    Scene scene = new Scene(new VBox(listView, btn));

    primaryStage.setScene(scene);
    primaryStage.show();
}

बड़ी संख्या में अपडेट का उपयोग करने के बजाय इसे रोकने के लिए, निम्न कोड फ़्रेम के अनुसार केवल एक बार अपडेट चलाने के लिए एक AnimationTimer का उपयोग करता है:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javafx.animation.AnimationTimer;

public class Updater {

    @FunctionalInterface
    public static interface UpdateTask {

        public void update() throws Exception;
    }

    private final List<UpdateTask> updates = new ArrayList<>();

    private final AnimationTimer timer = new AnimationTimer() {

        @Override
        public void handle(long now) {
            synchronized (updates) {
                for (UpdateTask r : updates) {
                    try {
                        r.update();
                    } catch (Exception ex) {
                        Logger.getLogger(Updater.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
                updates.clear();
                stop();
            }
        }
    };

    public void addTask(UpdateTask... tasks) {
        synchronized (updates) {
            updates.addAll(Arrays.asList(tasks));
            timer.start();
        }
    }

}

जो Updater वर्ग का उपयोग करके अपडेट को समूहीकृत करने की अनुमति देता है:

private final Updater updater = new Updater();

...

        // Platform.runLater(() -> data.add(index));
        updater.addTask(() -> data.add(index));

JavaFX सेवा का उपयोग कैसे करें

JavaFX Thread में गहन कार्यों को चलाने के बजाय एक Service में किया जाना चाहिए। क्या मूल रूप से एक सेवा है ?

एक सेवा एक वर्ग है जो हर बार जब आप इसे शुरू कर रहे हैं तो एक नया Thread बना रहे हैं और कुछ कार्य करने के लिए एक कार्य को पारित कर रहे हैं। सेवा वापस आ सकती है या एक मूल्य नहीं।

नीचे JavaFX सेवा का एक विशिष्ट उदाहरण दिया गया है, जो कुछ काम कर रहा है और एक Map<String,String>( लौटाता है Map<String,String>( ):

public class WorkerService extends Service<Map<String, String>> {

    /**
     * Constructor
     */
    public WorkerService () {

        // if succeeded
        setOnSucceeded(s -> {
            //code if Service succeeds
        });

        // if failed
        setOnFailed(fail -> {
            //code it Service fails
        });

        //if cancelled
        setOnCancelled(cancelled->{
            //code if Service get's cancelled
        });
    }

    /**
    * This method starts the Service
    */
    public void startTheService(){
        if(!isRunning()){
           //...
           reset();
           start();
        }

    }

    @Override
    protected Task<Map<String, String>> createTask() {
        return new Task<Map<String, String>>() {
            @Override
            protected Void call() throws Exception {

                    //create a Map<String, String>
                    Map<String,String> map  = new HashMap<>();

                   //create other variables here

                   try{
                        //some code here
                        //.....do your manipulation here

                        updateProgress(++currentProgress, totalProgress);
                    }

                } catch (Exception ex) {                  
                    return null; //something bad happened so you have to do something instead of returning null
                }

                return map;
            }
        };
    }

}