如何解决Java 使用线程发出数据库请求？

线程和JavaFX有两个基本规则：

1. 任何修改或访问场景图一部分的节点状态的代码都必须在JavaFX应用程序线程上执行。某些其他操作（例如，创建new Stage）也受此规则约束。
2. 任何可能花费很长时间运行的代码都应在后台线程上执行（即不在FX Application线程上执行）。 第一条规则的原因是，像大多数UI工具包一样，编写框架时对场景图的元素状态没有任何同步。添加同步会导致性能损失，这对于UI工具包来说是一笔过高的费用。因此，只有一个线程可以安全地访问此状态。由于UI线程（JavaFX的FX应用程序线程）需要访问此状态才能呈现场景，因此FX Application线程是唯一可以访问“实时”场景图状态的线程。在JavaFX 8和更高版本中，受此规则约束的大多数方法都会执行检查，并在违反该规则时抛出运行时异常。（这与Swing相反，在Swing中，你可以编写“非法”代码，并且看起来可能运行良好，但实际上在任意时间都容易出现随机且无法预测的故障。）这是IllegalStateException你看到的原因：你是courseCodeLbl.setText(...)从FX Application Thread之外的其他线程进行调用。

第二条规则的原因是，FX Application Thread不仅负责处理用户事件，还负责渲染场景。因此，如果你在该线程上执行了长时间运行的操作，则在该操作完成之前，UI才会呈现，并且将对用户事件无响应。虽然这不会产生异常或导致损坏的对象状态（如违反规则1那样），但（最多）它会带来不良的用户体验。

因此，如果你有一个长时间运行的操作（例如访问数据库），需要在完成时更新UI，则基本计划是在后台线程中执行长时间运行的操作，并在操作完成时返回操作结果完成，然后在UI（FX应用程序）线程上安排对UI的更新。所有单线程UI工具箱都有执行此操作的机制：在JavaFX中，你可以通过在FX Application Thread上Platform.runLater(Runnable r)执行调用来实现r.run()。（在Swing中，你可以调用在AWT事件分配线程上SwingUtilities.invokelater(Runnable r)执行r.run()。）JavaFX（请参见本答案后面的内容）还提供了一些高级API，用于管理与FX Application Thread的通信。

多线程通用良好实践

使用多个线程的最佳实践是将要在“用户定义”线程上执行的代码构造为具有某种固定状态初始化的对象，并具有执行该操作的方法，并在完成时返回一个对象代表结果。对于初始化状态和计算结果使用不可变的对象是非常理想的。这里的想法是尽可能消除任何可变状态从多个线程可见的可能性。从数据库访问数据非常适合以下习惯用法：你可以使用数据库访问的参数（搜索项等）来初始化“ worker”对象。执行数据库查询并获取结果集，使用该结果集填充域对象的集合，然后最后返回该集合。

在某些情况下，有必要在多个线程之间共享可变状态。当绝对必须这样做时，你需要仔细同步对该状态的访问，以避免观察到状态不一致的状态（还有其他更细微的问题需要解决，例如状态的活跃性等）。强烈建议在需要时使用高级库来为你管理这些复杂性。

JavaFX提供了一个并发API，专门用于在后台线程中执行代码，而该API专门用于在代码执行完成时（或执行期间）更新JavaFX UI。此API旨在与java.util.concurrentAPI进行交互，该API提供了用于编写多线程代码的常规工具（但没有UI挂钩）。中的键类javafx.concurrent是Task，它表示打算在后台线程上执行的单个一次性工作单元。此类定义了一个抽象方法，call()该方法不带任何参数，返回结果并可能引发检查的异常。用调用的方法Task实现。Runnablerun()call()Task还具有被保证更新状态的FX应用程序线程的方法，例如作为一个集合updateProgress(...)，updateMessage(...)等，这定义了一些可观察到的性质（例如state和value）：听众对这些属性将被通知的FX应用程序线程的变化。最后，有一些方便的方法来注册处理程序（setonSucceeded(...)，setonFailed(...)等）; 通过这些方法注册的所有处理程序也将在FX Application Thread上调用。

因此，从数据库检索数据的一般公式为：

1. 创建一个Task来处理对数据库的调用。
2. 使用Task执行数据库调用所需的任何状态初始化。
3. 实现任务的call()方法以执行数据库调用，并返回调用结果。
4. 向任务注册一个处理程序，以在完成后将结果发送到UI。
5. 在后台线程上调用任务。 对于数据库访问，我强烈建议将实际的数据库代码封装在一个对UI一无所知的单独类中（数据访问对象设计模式）。然后，让任务调用数据访问对象上的方法。

因此，你可能会有一个这样的DAO类（请注意，这里没有UI代码）：

public class WidgetDAO {

    // In real life, you might want a connection pool here, though for
    // desktop applications a single connection often suffices:
    private Connection conn ;

    public WidgetDAO() throws Exception {
        conn = ... ; // initialize connection (or connection pool...)
    }

    public List<Widget> getWidgetsByType(String type) throws sqlException {
        try (PreparedStatement pstmt = conn.prepareStatement("select * from widget where type = ?")) {
            pstmt.setString(1, type);
            ResultSet rs = pstmt.executeQuery();
            List<Widget> widgets = new ArrayList<>();
            while (rs.next()) {
                Widget widget = new Widget();
                widget.setName(rs.getString("name"));
                widget.setNumberOfBigRedButtons(rs.getString("btnCount"));
                // ...
                widgets.add(widget);
            }
            return widgets ;
        }
    }

    // ...

    public void shutdown() throws Exception {
        conn.close();
    }
}

检索一堆小部件可能会花费很长时间，因此来自UI类（例如，控制器类）的任何调用都应在后台线程上进行调度。控制器类可能如下所示：

public class MyController {

    private WidgetDAO widgetAccessor ;

    // java.util.concurrent.Executor typically provides a pool of threads...
    private Executor exec ;

    @FXML
    private TextField widgetTypeSearchField ;

    @FXML
    private TableView<Widget> widgetTable ;

    public void initialize() throws Exception {
        widgetAccessor = new WidgetDAO();

        // create executor that uses daemon threads:
        exec = Executors.newCachedThreadPool(runnable -> {
            Thread t = new Thread(runnable);
            t.setDaemon(true);
            return t ;
        });
    }

    // handle search button:
    @FXML
    public void searchWidgets() {
        final String searchString = widgetTypeSearchField.getText();
        Task<List<Widget>> widgetSearchTask = new Task<List<Widget>>() {
            @Override
            public List<Widget> call() throws Exception {
                return widgetAccessor.getWidgetsByType(searchString);
            }
        };

        widgetSearchTask.setonFailed(e -> {
           widgetSearchTask.getException().printstacktrace();
            // inform user of error...
        });

        widgetSearchTask.setonSucceeded(e -> 
            // Task.getValue() gives the value returned from call()...
            widgetTable.getItems().setAll(widgetSearchTask.getValue()));

        // run the task using a thread from the thread pool:
        exec.execute(widgetSearchTask);
    }

    // ...
}

请注意，对（可能）长时间运行的DAO方法的调用是如何包装在一个Task在后台线程中（通过访问器）运行的中的，以防止阻塞UI（上述规则2）。widgetTable.setItems(...)实际上，使用Task的便捷回调方法setonSucceeded(...)（满足规则1）在FX Application线程上执行了对UI（）的更新。

在你的情况下，你正在执行的数据库访问将返回单个结果，因此你可能具有类似以下的方法

public class MyDAO {

    private Connection conn ; 

    // constructor etc...

    public Course getCourseByCode(int code) throws sqlException {
        try (PreparedStatement pstmt = conn.prepareStatement("select * from course where c_code = ?")) {
            pstmt.setInt(1, code);
            ResultSet results = pstmt.executeQuery();
            if (results.next()) {
                Course course = new Course();
                course.setName(results.getString("c_name"));
                // etc...
                return course ;
            } else {
                // maybe throw an exception if you want to insist course with given code exists
                // or consider using Optional<Course>...
                return null ;
            }
        }
    }

    // ...
}

然后你的控制器代码看起来像

final int courseCode = Integer.valueOf(courseId.getText());
Task<Course> courseTask = new Task<Course>() {
    @Override
    public Course call() throws Exception {
        return myDAO.getCourseByCode(courseCode);
    }
};
courseTask.setonSucceeded(e -> {
    Course course = courseTask.getCourse();
    if (course != null) {
        courseCodeLbl.setText(course.getName());
    }
});
exec.execute(courseTask);

该api文档Task有更多的例子，包括更新progress任务的属性进度条…等（有用

解决方法

    package application;

import java.sql.ResultSet;
import java.sql.SQLException;

import javafx.fxml.FXML;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;

public class Controller{
    @FXML
    private Button getCourseBtn;
    @FXML
    private TextField courseId;
    @FXML
    private Label courseCodeLbl;
    private ModelController mController;

    private void requestCourseName(){
        String courseName = "";
        Course c = new Course();
        c.setCCode(Integer.valueOf(courseId.getText()));
        mController = new ModelController(c);
        try {
            ResultSet rs = mController.<Course>get();
            if(rs.next()){
                courseCodeLbl.setText(rs.getString(1));
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
//      return courseName;
    }

    public void getCourseNameOnClick(){
        try {
//              courseCodeLbl.setText(requestCourseName());
            Thread t = new Thread(new Runnable(){
                public void run(){
                    requestCourseName();
                }
            },"Thread A");
            t.start();
        } catch (NumberFormatException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

Runnable task = new Runnable() {
    @Override
    public void run() {
        System.out.println("Execute task.");
    }
};

Runnable task = ()->{
    System.out.println("Execute task.");
};

Callable<String> callableTask = ()-> "finished";

// 创建线程数量为5的线程池。
ExecutorService executorService = Executors.newFixedThreadPool(5);

//创建一个可缓存的线程池 
ExecutorService executorService = Executors.newCachedThreadPool();

//创建一个单线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();

//创建一个工作窃取线程池，使用CPU核数等于机器的CPU核数
ExecutorService executorService = Executors.newWorkStealingPool();

//创建一个工作窃取线程池，使用CPU 3 个核进行计算，工作窃取线程池不能设置线程数
ExecutorService executorService2 = Executors.newWorkStealingPool(3);

// 获取一个大小为2的计划任务线程池
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);

// 添加一个打印当前线程信息计划任务，该任务在3秒后执行
scheduledExecutorService.schedule(() -> { System.out.println(Thread.currentThread()); }, 3,  TimeUnit.SECONDS);

// 添加一个打印当前线程信息计划任务，该任务在2秒后首次执行，之后每5秒执行一次。如果任务执行时间超过了5秒，则下一次将会在前一次执行完成之后立即执行
scheduledExecutorService.scheduleAtFixedRate(() -> { System.out.println(Thread.currentThread()); }, 2, 5, TimeUnit.SECONDS);

// 添加一个打印当前线程信息计划任务，该任务在2秒后首次执行，之后每次在任务执行之后5秒执行下一次。
scheduledExecutorService.scheduleWithFixedDelay(() -> { System.out.println(Thread.currentThread()); }, 2, 5, TimeUnit.SECONDS);

// 逐个清除 idle 状态的线程
scheduledExecutorService.shutdown();

// 阻塞，在线程池被关调之前代码不再往下走
scheduledExecutorService.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(3);

//提交一个无返回值的任务（实现了Runnable接口）
executorService.submit(()->System.out.println("Hello"));

executorService.shutdown();
executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(3);
List<Runnable> tasks = Arrays.asList(
        ()->System.out.println("Hello"),
        ()->System.out.println("World"));

//逐个提交任务
tasks.forEach(executorService::submit);

executorService.shutdown();
executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);

ExecutorService executorService = Executors.newFixedThreadPool(2);
Future<String> future = executorService.submit(()->"Hello");
System.out.println(future.isDone());//false
String value = future.get();
System.out.println(future.isDone());//true
System.out.println(value);//Hello

ExecutorService executorService = Executors.newFixedThreadPool(2);
List<Callable<String>> tasks = Arrays.asList(()->"Hello", ()->"World");
List<Future<String>> futures = executorService.invokeAll(tasks);

ExecutorService executorService = Executors.newFixedThreadPool(2);
List<Callable<String>> tasks = Arrays.asList(
        () -> {
            Thread.sleep(500L);
            System.out.println("Hello");
            return "Hello";
        }, () -> {
            System.out.println("World");
            return "World";
        });
String s = executorService.invokeAny(tasks);
System.out.println(s);//World

World
World

ExecutorService executorService = Executors.newFixedThreadPool(1);
Future<String> future = executorService.submit(() -> System.out.println("Hello"), "World");
System.out.println(future.get());//输出：World

1 public static ExecutorService newCachedThreadPool() {
2         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
3                                       60L, TimeUnit.SECONDS,
4                                       new SynchronousQueue<Runnable>());
5 }

 1 @Configuration
 2 public class TreadPoolConfig {
 3 
 4 
 5     /**
 6      * 消费队列线程
 7      * @return
 8      */
 9     @Bean(value = "consumerQueueThreadPool")
10     public ExecutorService buildConsumerQueueThreadPool(){
11         ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
12                 .setNameFormat("consumer-queue-thread-%d").build();
13 
14         ExecutorService pool = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
15                 new ArrayBlockingQueue<Runnable>(5),namedThreadFactory,new ThreadPoolExecutor.AbortPolicy());
16 
17         return pool ;
18     }
19 
20 
21 
22 }

 1 　　@Resource(name = "consumerQueueThreadPool")
 2     private ExecutorService consumerQueueThreadPool;
 3 
 4 
 5     @Override
 6     public void execute() {
 7 
 8         //消费队列
 9         for (int i = 0; i < 5; i++) {
10             consumerQueueThreadPool.execute(new ConsumerQueueThread());
11         }
12 
13     }