“相同”时间的JDBC Open 2连接

Question

I'm currently trying to open 2 JDBC Connections at the same time, which results in both threads blocking at the "getConnection" call. I use a self-written TaskManager (which is a simple Thread-Pool for javafx-Tasks with callbacks) to submit my TestConnectionTask with a max Threadcount of 8. When I set the max Threadcount to 1 everything works just fine.

Here's the relevant code:

Submitting the Tasks:

TaskManager.getInstance().submitTask(new TestConnectionTask(
    new MSSQLConnector(),
    this.dbConnectController1.getModel().getHost(),
    this.dbConnectController1.getModel().getUser(),
    this.dbConnectController1.getModel().getPassword(),
    this.dbConnectController1.getModel().getDatabase(),
    5-- timeout in seconds
), this::onDB1Connected);

TaskManager.getInstance().submitTask(new TestConnectionTask(
    new MySQLConnector(),
    this.dbConnectController2.getModel().getHost(),
    this.dbConnectController2.getModel().getUser(),
    this.dbConnectController2.getModel().getPassword(),
    this.dbConnectController2.getModel().getDatabase(),
    5-- timeout in seconds
), this::onDB2Connected);

The TestConnectionTask Class:

public class TestConnectionTask extends Task<SavingDBConnector>
{
    private final DBConnector connector;
    private final String host;
    private final String user;
    private final String password;
    private final String database;
    private final int timeout;

    public TestConnectionTask(DBConnector connector, String host, String user, String password, String database, int timeout)
    {
        super();
        updateTitle("Verbindungstest");

        this.connector = connector;
        this.host = host;
        this.user = user;
        this.password = password;
        this.database = database;
        this.timeout = timeout;
    }

    @Override
    protected SavingDBConnector call() throws Exception
    {
        updateProgress(0L, 2L);
        updateMessage("Verbindungsversuch");

        try (Connection conn = this.connector.openConnection(this.host, this.user, this.password, this.database, this.timeout))
        {
            updateProgress(1L, 2L);
        }
        catch (Exception e)
        {
            updateMessage("Beim Herstellen der Verbindung ist ein Fehler aufgetreten");
            throw e;
        }

        updateProgress(2L, 2L);
        updateMessage("Verbindung erfolgreich hergstellt");

        return new SavingDBConnector(this.connector, this.host, this.user, this.password, this.database, this.timeout);
    }
}

The DBConnector Class:

public abstract class DBConnector
{
    private final String jdbcClassName;
    private final String jdbcSubprotocol;
    private boolean jdbcClassLoaded;

    public DBConnector(String jdbcClassName, String jdbcSubprotocol)
    {
        this.jdbcClassName = jdbcClassName;
        this.jdbcSubprotocol = jdbcSubprotocol;
        this.jdbcClassLoaded = false;
    }

    public Connection openConnection(String host, String user, String password, String database, int timeout) throws SQLException, ClassNotFoundException
    {
        if (!this.jdbcClassLoaded)
        {
            Class.forName(this.jdbcClassName);
            this.jdbcClassLoaded = true;
        }

        Properties properties = new Properties();
        properties.setProperty("User", user);
        properties.setProperty("Password", password);

        if (timeout > 0)
        {
            properties.setProperty("LoginTimeout", Integer.toString(timeout));
        }

        Connection conn = DriverManager.getConnection(String.format("jdbc:%s://%s", this.jdbcSubprotocol, host), properties);
        conn.setCatalog(database);

        return conn;
    }
}

The Implementations MSSQL and MySQL simply construct it like that:

super("com.microsoft.sqlserver.jdbc.SQLServerDriver", "sqlserver");
and
super("com.mysql.jdbc.Driver", "mysql");

And last but not least the TaskThreadPool, which is the Superclass of my Project-Spefific TaskManager

public class TaskThreadPool
{
    private int maxThreadCount;
    private int currentThreadCount;
    private final Object lockCurrentThreadCount;
    private final ConcurrentLinkedQueue<TaskWithCallback<?>> queue;

    public TaskThreadPool()
    {
        this.maxThreadCount = 1;
        this.currentThreadCount = 0;
        this.lockCurrentThreadCount = new Object();
        this.queue = new ConcurrentLinkedQueue<>();
    }

    public void setMaxThreadCount(int maxThreadCount)
    {
        this.maxThreadCount = maxThreadCount;
    }

    public int getMaxThreadCount()
    {
        return this.maxThreadCount;
    }

    public <T> void submitTask(Task<? extends T> task, TaskCallback<T> callback)
    {
        this.queue.offer(new TaskWithCallback<>(task, callback));

        synchronized (this.lockCurrentThreadCount)
        {
            if (this.currentThreadCount < this.maxThreadCount)
            {
                this.currentThreadCount++;

                Thread thread = new Thread(this::threadRun);
                thread.setDaemon(true);
                thread.start();
            }
        }
    }

    private void threadRun()
    {
        while (true)
        {
            TaskWithCallback<?> taskWithCallback;
            while ((taskWithCallback = this.queue.poll()) != null)
            {
                taskWithCallback.run();
            }

            synchronized (this.lockCurrentThreadCount)
            {
                // Sonst möglicherweise tote Tasks
                if (this.queue.isEmpty())
                {
                    this.currentThreadCount--;
                    break;
                }
            }
        }
    }

    private class TaskWithCallback<T> implements Runnable
    {
        private final Task<? extends T> task;
        private final TaskCallback<T> callback;

        public TaskWithCallback(Task<? extends T> task, TaskCallback<T> callback)
        {
            this.task = task;
            this.callback = callback;
        }

        @Override
        public void run()
        {
            this.task.run();
            if (this.callback != null)
            {
                Platform.runLater(() -> this.callback.onTaskCompleted(this.task.getValue()));
            }
        }
    }

    public interface TaskCallback<T>
    {
        public void onTaskCompleted(T result);
    }
}

Answer 1

I'm now using the following synchronized static Method in my DBConnector to open the connections one after the other as a workaround

private synchronized static Connection getConnection(String url, Properties info) throws SQLException
{
    return DriverManager.getConnection(url, info);
}

Still looking forward to find a solution which allows me to open multiple connections parallel