Question

I have been given the task of creating a sql database and creating a GUI in Java to access it with. I pretty much have it but I have a question about threads. Before today I did not use any threads in my program and as a result just to pull 150 records from the database i had to wait around 5 – 10 seconds. This was very inconvenient and I was not sure if i could fix the issue. Today I looked on the internet about using threads in programs similar to mine and i decided to just use one thread in this method:

public Vector VectorizeView(final String viewName) {
    final Vector table = new Vector();
    int cCount = 0;
    try {
        cCount = getColumnCount(viewName);
    } catch (SQLException e1) {
        e1.printStackTrace();
    }
    final int viewNameCount = cCount;

    Thread runner = new Thread(){

        public void run(){
            try {
                Connection connection = DriverManager.getConnection(getUrl(),
                        getUser(), getPassword());
                Statement statement = connection.createStatement();
                ResultSet result = statement.executeQuery("Select * FROM "
                        + viewName);
                while (result.next()) {
                    Vector row = new Vector();
                    for (int i = 1; i <= viewNameCount; i++) {
                        String resultString = result.getString(i);
                        if (result.wasNull()) {
                            resultString = "NULL";
                        } else {
                            resultString = result.getString(i);
                        }
                        row.addElement(resultString);

                    }
                    table.addElement(row);
                }
            } catch (SQLException e) {

                e.printStackTrace();
            }
        }
    };
    runner.start();
    return table;

}

The only thing i really changed was adding the thread ‘runner’ and the performance increased exponentially. Pulling 500 records occurs almost instantly this way.

The method looked like this before:

public Vector VectorizeTable(String tableName) {

    Vector<Vector> table = new Vector<Vector>();
    try {
        Connection connection = DriverManager.getConnection(getUrl(),
                getUser(), getPassword());
        Statement statement = connection.createStatement();
        ResultSet result = statement.executeQuery("Select * FROM "
                + tableName);
        while (result.next()) {
            Vector row = new Vector();
            for (int i = 1; i <= this.getColumnCount(tableName); i++) {
                String resultString = result.getString(i);
                if (result.wasNull()) {
                    resultString = "NULL";
                } else {
                    resultString = result.getString(i);
                }
                row.addElement(resultString);

            }
            table.addElement(row);
        }
    } catch (SQLException e) {

        e.printStackTrace();
    }
    return table;
}

My question is why is the method with the thread so much faster than the one without? I don’t use multiple threads anywhere in my program. I have looked online but nothing seems to answer my question.

Any information anyone could give would be greatly appreciated. I’m a noob on threads XO

If you need any other additional information to help understand what is going on let me know!

Answer:

Look at Aaron’s answer this wasn’t an issue with threads at all. I feel very noobish right now :(. THANKS @Aaron!

Answer 1

It looks like you kick off (i.e. start) a background thread to perform the query, but you don’t join to wait for the computation to complete. When you return table, it won’t be filled in with the results of the query yet — the other thread will fill it in over time, after your method returns. The method returns almost instantly, because it’s doing no real work.

If you want to ensure that the data is loaded before the method returns, you’ll need to call runner.join(). If you do so, you’ll see that loading the data is taking just as long as it did before. The only difference with the new code is that the work is performed in a separate thread of execution, allowing the rest of your code to get on with other work that it needs to perform. Note that failing to call join could lead to errors if code in your main thread tries to use the data in the Vector before it’s actually filled in by the background thread.

Update: I just noticed that you’re also precomputing getColumnCount in the multi-threaded version, while in the single-threaded version you’re computing it for each iteration of the inner loop. Depending on the complexity of that method, that might explain part of the speedup (if there is any).