Java 线程执行期间（/之后）数据的可见性

在本例中，有一个输入类和一个结果类的实例。 输入实例填充在GUI线程中，这里是JavaFX应用程序线程。 按下按钮后，此输入实例将在工作线程中使用。然后，工作线程创建结果类的一个实例，并在调用this Platform.runLater更新GUI后用一些值填充它

我的第一个问题是： 是否保证工作线程看到输入实例的值？

我会说是的，因为： JLS 17.4.5。发生在订单之前，表示： 对线程的start（）调用发生在已启动线程中的任何操作之前

因此，在我看来，在调用start之前，JavaFX线程中所做的一切都是 将对工作线程可见

我的第二个问题是： 是否保证JavaFX应用程序线程看到结果实例的值？

我想是的，但我不确定。Platform.runLater会确保这一点吗？怎么做

package javafxconcurrency;

import javafx.application.Application;
import javafx.application.Platform;
import javafx.concurrent.Task;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class JavaFxConcurrency extends Application {

    private Input input;

    @Override
    public void start(Stage primaryStage) {
        input = new Input();
        input.setId(1);
        input.setName("Jack");

        Button btn = new Button();
        btn.setText("Start a thread");
        btn.setOnAction(new EventHandler<ActionEvent>() {

            @Override
            public void handle(ActionEvent event) {
                Task<Result> task = new Task() {

                    @Override
                    protected Object call() throws Exception {
                        final Result result = queryDB(input);
                        Platform.runLater(new Runnable() {

                            @Override
                            public void run() {
                                updateGUI(result);
                            }

                        });
                        return result;
                    }

                    private Result queryDB(Input input) {
                        try {
                            Thread.sleep(3000);
                            Result result = new Result();
                            result.setId(System.currentTimeMillis());
                            result.setName(input.getName());
                            return result;
                        } catch (InterruptedException ex) {
                            throw new RuntimeException(ex);
                        }
                    }

                };
                Thread workerThread = new Thread(task);
                workerThread.setDaemon(true);
                workerThread.start();
            }

        });

        StackPane root = new StackPane();
        root.getChildren().add(btn);

        Scene scene = new Scene(root, 300, 250);

        primaryStage.setTitle("Visibilty");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    private void updateGUI(Result result) {
        System.out.println("result" + result);
    }

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

    private static class Input {

        private long id;

        private String name;

        public void setId(long id) {
            this.id = id;
        }

        public long getId() {
            return id;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

    }

    private static class Result {

        private long id;

        private String name;

        public void setId(long id) {
            this.id = id;
        }

        public long getId() {
            return id;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        @Override
        public String toString() {
            return "Result{" + "id=" + id + ", name=" + name + '}';
        }

    }

}

包javafxconcurrency；
导入javafx.application.application；
导入javafx.application.Platform；
导入javafx.concurrent.Task；
导入javafx.event.ActionEvent；
导入javafx.event.EventHandler；
导入javafx.scene.scene；
导入javafx.scene.control.Button；
导入javafx.scene.layout.StackPane；
导入javafx.stage.stage；
公共类JavaFxConcurrency扩展了应用程序{
私人投入；
@凌驾
公共无效开始（阶段primaryStage）{
输入=新输入（）；
输入setId（1）；
输入.setName（“Jack”）；
按钮btn=新按钮（）；
btn.setText（“启动线程”）；
btn.setOnAction（新的EventHandler（）{
@凌驾
公共无效句柄（ActionEvent事件）{
任务=新任务（）{
@凌驾
受保护对象调用（）引发异常{
最终结果=查询DB（输入）；
Platform.runLater（新的Runnable（）{
@凌驾
公开募捐{
更新GUI（结果）；
}
});
返回结果；
}
私有结果查询DB（输入）{
试一试{
睡眠（3000）；
结果=新结果（）；
result.setId（System.currentTimeMillis（））；
result.setName（input.getName（））；
返回结果；
}捕获（中断异常例外）{
抛出新的运行时异常（ex）；
}
}
};
线程工作线程=新线程（任务）；
workerThread.setDaemon（true）；
workerThread.start（）；
}
});
StackPane root=新的StackPane（）；
root.getChildren（）.add（btn）；
场景=新场景（根，300，250）；
初级阶段。设置标题（“可视性”）；
初级阶段。场景（场景）；
primaryStage.show（）；
}
私有void updateGUI（结果）{
系统输出打印项次（“结果”+结果）；
}
公共静态void main（字符串[]args）{
发射（args）；
}
私有静态类输入{
私人长id；
私有字符串名称；
公共无效集合id（长id）{
this.id=id；
}
公共长getId（）{
返回id；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共字符串getName（）{
返回名称；
}
}
私有静态类结果{
私人长id；
私有字符串名称；
公共无效集合id（长id）{
this.id=id；
}
公共长getId（）{
返回id；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共字符串getName（）{
返回名称；
}
@凌驾
公共字符串toString（）{
返回“Result{”+“id=“+id+”，name=“+name+'}”；
}
}
}

是否保证工作线程看到输入实例的值

是：

Thread#start

创建“发生在发生之前”关系。所以你有：

• input.setName（“Jack”）发生在
  workerThread.start（）之前因为它们都在FX线程上，所以您可以获得程序顺序的保证

• workerThread.start（）；发生在

  result.setName（input.getName（））之前由于您提到的原因（线程启动前的所有操作都发生在该线程中执行的任何操作之前）

是否保证JavaFX应用程序线程看到结果实例的值

是的，

Platform.runLater

还提供了一个before-before关系，如所示：“此方法[…]可以从任何线程调用”。如果您不确信，可以查看一下，您将看到有几个同步点

没有这种保证，如果不手动同步所有内容，就不可能与JavaFX组件通信