我正在开发一个访问 SQLite 数据库的应用程序。问题是数据库在有查询时被锁定。大多数时候这不是问题，因为应用程序的流程是线性的。

但是我有一个很长的计算过程，它是由用户触发的。此过程涉及在计算之间多次调用数据库。

我希望用户获得一些视觉反馈，因此我一直在使用 Javafx progressIndicator 和来自 Javafx.Concurrency 框架的服务。 问题是这让用户可以自由地在应用程序中移动，并可能触发对数据库的其他调用。

这导致了数据库文件被锁定的异常。 当这种情况发生时，我想要一种方法来阻止该线程运行，但是我无法在网上找到任何明确的示例。他们中的大多数都过于简单化，我想要一种可扩展的方式。我试过使用 cancel() 方法，但这并不能保证线程会被及时取消。

因为我无法检查 isCancelled 代码的所有部分，所以有时线程被取消的时间和它有效停止的时间之间存在延迟。

所以我想到了以下解决方案，但我想知道在效率和避免竞争条件和挂起方面是否有更好的方法。

    // Start service
    final CalculatorService calculatorService = new CalculatorService();

    // Register service with thread manager
    threadManager.registerService(CalculatorService);

    // Show the progress indicator only when the service is running
    progressIndicator.visibleProperty().bind(calculatorService.runningProperty());

calculatorService.setOnSucceeded(new EventHandler<WorkerStateEvent>() {
        @Override
        public void handle(WorkerStateEvent workerStateEvent) {
            System.out.println("SUCCEEDED");
            calculatorService.setStopped(true);
        }
    });

    // If something goes wrong display message
    calculatorService.setOnFailed(new EventHandler<WorkerStateEvent>() {
        @Override
        public void handle(WorkerStateEvent workerStateEvent) {
            System.out.println("FAILED");
            calculatorService.setStopped(true);
        }
    });

    // Restart the service
    calculatorService.restart(); 

这是我的服务类，我将其子类化以包含可用于设置服务状态(已停止或未停止)的方法

    public class CalculatorService extends Service implements CustomService {
    private AtomicBoolean stopped;
    private CalculatorService serviceInstance;

    public FindBundleService() {
        stopped = new AtomicBoolean(false);
        instance = this;
    }

    @Override
    protected Task<Results> createTask() {
        return new Task<Result>() {

            @Override
            protected Result call() throws Exception {
                try {
                    Result = calculationMethod(this, serviceInstance);
                    return Result;
                } catch (Exception ex) {
                    // If the thread is interrupted return
                    setStopped(true);
                    return null;
                }
            }
        };
    }

    @Override
    public boolean isStopped() {
        return stopped.get();
    }

    @Override
    public void setStopped(boolean stopped) {
        this.stopped.set(stopped);
    }
}

服务实现了我定义的这个接口(interface)

public interface CustomService {

    /**
     * Method to check if a service has been stopped
     * 
     * @return
     */
    public boolean isStopped();

    /**
     * Method to set a service as stopped
     * 
     * @param stopped
     */
    public void setStopped(boolean stopped);

}

所有服务都必须向单例类的线程管理器注册自己。

public class ThreadManager {

    private ArrayList<CustomService> services;

    /**
     * Constructor
     */
    public ThreadManager() {
        services = new ArrayList<CustomService>();
    }

    /**
     * Method to cancel running services
     */
    public boolean cancelServices() {
        for(CustomService service : services) {
            if(service.isRunning()) {
                ((Service) service).cancel();
                while(!service.isStopped()) {
                    // Wait for it to stop
                }
            }
        }
        return true;
    }


    /**
     * Method to register a service
     */
    public void registerService(CustomService service) {
        services.add(service);
    }

    /**
     * Method to remove a service
     */
    public void removeService(CustomService service) {
        services.remove(service);
    }

}

如果我们想停止服务，可以在应用程序的任何地方调用 cancelServices()。这会将状态设置为取消我正在我的 calculationMethod() 中检查这个然后将状态设置为在返回之前停止(有效地结束线程)。

if(task.isCancelled()) {
        service.setStopped(true);
        return null;
}

最佳答案

(我假设您正在使用 JDBC 进行数据库查询，并且您可以控制运行查询的代码)

我会将所有数据库访问集中在一个单例类中，这将使最后一个 PreparedStatement 在单个线程中运行当前查询 ExecutorService .然后，您可以向该单例实例询问 isQueryRunning()、runQuery()、cancelQuery() 等将同步 所以你可以决定在计算应该被取消时向用户显示一条消息，取消它并开始一个新的。

类似于(添加空检查和 catch (SQLException e) block ):

public class DB {

    private Connection cnx;
    private PreparedStatement lastQuery = null;
    private ExecutorService exec = Executors.newSingleThreadExecutor(); // So you execute only one query at a time

    public synchronized boolean isQueryRunning() {
        return lastQuery != null;
    }

    public synchronized Future<ResultSet> runQuery(String query) {
        // You might want to throw an Exception here if lastQuery is not null (i.e. a query is running)
        lastQuery = cnx.preparedStatement(query);
        return exec.submit(new Callable<ResultSet>() {
            public ResultSet call() {
                try {
                    return lastQuery.executeQuery();
                } finally { // Close the statement after the query has finished and return it to null, synchronizing
                    synchronized (DB.this) {
                        lastQuery.close();
                        lastQuery = null;
                    }
                }
            }
            // Or wrap the above Future<ResultSet> so that Future.cancel() will actually cancel the query
    }

    public synchronized void cancelQuery() {
        lastQuery.cancel(); // I hope SQLite supports this
        lastQuery.close();
        lastQuery = null;
    }

}

关于java - 管理使用 Java 访问数据库的线程，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45969970/