Statement.cancel() isn't working

Question

Neither statement.cancel() nor the query timeout functionality seem to work. I'm using the MySQL connector-J driver, but the forum over there doesn't have any ideas. The program's fairly simple and it keeps a log of what's going on. Basically, if I execute a query on one thread and cancel it on another, the cancel doesn't seem to get through to the driver, according to the MySQL log, although the cancel statement is accepted without any form of error.
A similar thing happens with the query timeout - it just doesn't occur and the system waits until the query terminates normally.
One possibility is that the MySQL server and client program are on the same machine - would that make a difference? The GUI's still responsive (that's what I use to generate the queries and cancels).
The code's here - the threading is a bit unnecessarily complex but shouldn't affect anything. The log from an attempted cancel follows. The events were to start a query and a few seconds later call cancel. Sorry it's a bit long, but it couldn't be shortened much. The important methods are query() which starts a query, cancel() which cancels it (in theory), and the private class UserConn which implements the thread which does the database interaction.
Ignore the wait timeout stuff - that was put in to see what happened if a connection wasn't used for a certain length of time and doesn't affect this issue.
package com.ptoye.TestConnection;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import javax.swing.ProgressMonitor;
import javax.swing.Timer;
* @author PToye
public class UserConnection {
  private static final int WAIT_TIMEOUT=60;
  private static final int TIMER_FREQUENCY=WAIT_TIMEOUT/4;
  private static final int QUERY_TIMEOUT=6;
  private static Object timerLock=new Object();
  private static boolean timerToDo=false;
  private static Timer idleTimer;
  private static Connection connUser=null;
  private static String userName;
  private static boolean inCommand;
  private static boolean anythingToDo;
  private static boolean closeIt;
  private static boolean queryIt;
  private static boolean wakeUp;
  private static Thread connThread;
  private static Thread userThread;
  private static final String command="select count(*) from larger" +
      " where data like '%a_a%' or data like '%z_z%' or data like '%qw_e%'" +
      " or data like '%r__t%' or data like '%e__r%'";
  private static final String DUMMY_QUERY="SELECT 1";
  private static FrameConnection caller;
  private static int queryId;
  private static boolean endStatus;
  private static int endStatusValue;
  private static Statement st=null;
  private static DatabaseMetaData dmd;
  public UserConnection() {
    if (connUser!=null) {
      return;
    userThread=Thread.currentThread();
    infoMessage("Start connection");
    try {
      Class.forName("com.mysql.jdbc.Driver").newInstance();
    } catch (IllegalAccessException ex) {
      ex.printStackTrace();
    } catch (ClassNotFoundException ex) {
      ex.printStackTrace();
    } catch (InstantiationException ex) {
      ex.printStackTrace();
    try {
      connUser = DriverManager.getConnection
          ("jdbc:mysql://localhost/?user=test&password=test");
      st=connUser.createStatement();
      st.setQueryTimeout(QUERY_TIMEOUT);
      st.executeUpdate("SET SESSION wait_timeout="+WAIT_TIMEOUT);
      st.executeUpdate("use largedata");
    } catch (SQLException ex) {
      ex.printStackTrace();
      return;
    inCommand=false;
    anythingToDo=false;
    closeIt=false;
    queryIt=false;
    wakeUp=false;
    timerToDo=true;
    infoMessage("Created new connection");
    connThread=new Thread(new UserConn());
    connThread.setName("Connection");
    connThread.start();
    infoMessage("Thread started");
    ActionListener timerAction=new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        synchronized (timerLock) {
          if (timerToDo) {
            infoMessage("Connection timeout");
            synchronized (connUser) {
              wakeUp=true;
              anythingToDo=true;
              connUser.notifyAll();
          } else {
            infoMessage("Connection timeout - nothing to do");
          timerToDo=true;
// timeout code wasn't there originally   
//   idleTimer=new Timer(TIMER_FREQUENCY*1000,timerAction);
//   idleTimer.setLogTimers(true);
//   idleTimer.start();
  public static boolean query(FrameConnection f, int id) {
    if (connUser!=null) {
      synchronized (connUser) {
        if (inCommand) {
          infoMessage("Already in query");
          return false;
        inCommand=true;
        anythingToDo=true;
        if (f!=null) {
          caller=f;
        queryId=id;
        queryIt=true;
        synchronized (timerLock) {
          timerToDo=false;
        infoMessage("Notifying connection to query");
        connUser.notifyAll();
        return true;
    } else {
      infoMessage("No connection");
      return false;
  public static void close() {
    if (connUser!=null) {
      synchronized (connUser) {
        closeIt=true;
        anythingToDo=true;
        idleTimer.stop();
        infoMessage("Notifying connection to close");
        connUser.notifyAll();
      try {
        connThread.join();
      } catch (InterruptedException ex) {
        ex.printStackTrace();
      infoMessage("Thread joined or timed out");
      try {
        st.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
  static void infoMessage(String s) {
    String now=new java.util.Date().toString();
    System.out.println(Thread.currentThread().getName()+": "+now+": "+s);
    System.out.flush();
  static void queryEnded() {
    synchronized (connUser) {
      inCommand=false;
      if (!endStatus  && endStatusValue==0) {
        infoMessage("Connection lost - try to re-establish");
        try {
          connUser = DriverManager.getConnection
              ("jdbc:mysql://localhost/?user=test&password=test");
        } catch (SQLException ex) {
          ex.printStackTrace();
        try {
          if (st.getConnection()!=connUser) {
            infoMessage("New connection not same as old");
            return;
        } catch (SQLException ex) {
          ex.printStackTrace();
        infoMessage("Try query again");
        query(null,queryId);
        return;
      caller.queryEnded(queryId,endStatus);
  static boolean cancelQuery() {
    infoMessage("Trying to cancel query "+queryId);
    try {
      st.cancel();
    } catch (SQLException ex) {
      return false;
    return true;
  private static class UserConn implements Runnable {
    public void run() {
      synchronized (connUser) {
        while (!anythingToDo) {
          try {
            infoMessage("Waiting");
            connUser.wait();
          } catch (InterruptedException ex) {
            infoMessage("Wait interrupted");
          if (anythingToDo) {
            infoMessage("Something to do");
            if (closeIt) {
              infoMessage("Asked to close");
              try {
                infoMessage("Starting to close");
                connUser.close();
              } catch (SQLException ex) {
                ex.printStackTrace();
              infoMessage("Closed");
              closeIt=false;
              connUser=null;
              return;
            } else if (queryIt) {
              try {
                queryIt=false;
                UserConnection.endStatus=true;
                infoMessage("Starting query "+UserConnection.queryId);
                st.executeQuery(UserConnection.command);
              } catch (SQLException ex) {
                infoMessage("Failed to execute query");
                infoMessage("Status was "+ex.getErrorCode()+":"+ex.getMessage());
                UserConnection.endStatus=false;
                UserConnection.endStatusValue=ex.getErrorCode();
              } catch (Exception e) {
                infoMessage("Query ended unexpectedly "+e.getMessage());
                UserConnection.endStatus=false;
                UserConnection.endStatusValue=-1;
              } finally {
                infoMessage("Query finished "+UserConnection.queryId);
                EventQueue.invokeLater(new Runnable() {
                  public void run() {
                    UserConnection.queryEnded();
            } else if (wakeUp) {
              wakeUp=false;
              try {
                infoMessage("Executing wakeup query");
                st.executeQuery(UserConnection.DUMMY_QUERY);
              } catch (SQLException ex) {
                ex.printStackTrace();
            infoMessage("Waiting again");
            anythingToDo=false;
}This is the MySQL log. as you can see - there's no kill attempt there.
C:\Program Files\MySQL\MySQL Server 5.0\bin\mysqld-nt, Version: 5.0.18-nt-log. started with:
TCP Port: 3306, Named Pipe: (null)
Time Id Command Argument
061007 12:10:43 1 Connect test@localhost on
1 Query SET NAMES utf8
1 Query SET character_set_results = NULL
1 Query SHOW VARIABLES
1 Query SHOW COLLATION
1 Query SET autocommit=1
1 Query SET SESSION wait_timeout=12000
1 Query use largedata
061007 12:10:46 1 Query select count(*) from larger where data like '%a_a%' or data like '%z_z%' or data like '%qw_e%' or data like '%r__t%' or data like '%e__r%'
061007 12:11:06 1 Quit
And the program trace output (with a few comments) is:
AWT-EventQueue-0: Sat Oct 07 12:10:46 BST 2006: Notifying connection to query
AWT-EventQueue-0: Sat Oct 07 12:10:46 BST 2006: Start query 1
Connection: Sat Oct 07 12:10:46 BST 2006: Starting query 1
// the statement.ExecuteQuery has been called from the Connection thread
AWT-EventQueue-0: Sat Oct 07 12:10:48 BST 2006: Trying to cancel query 1
AWT-EventQueue-0: Sat Oct 07 12:10:48 BST 2006: Query 1 cancel accepted: true
// this means that the statement.cancel() was called and didn't produce an SQLException
Connection: Sat Oct 07 12:11:00 BST 2006: Query finished 1
// the query ended OK without an exception
Connection: Sat Oct 07 12:11:00 BST 2006: Waiting
// Connection thread is waiting for something to do
AWT-EventQueue-0: Sat Oct 07 12:11:00 BST 2006: Query ended 1: true
// Main thread recived notification that the query ended OK

Answer 1

I take some of your points - I should have explained a bit more.
Sorry if it wasn't complete enough - I'm including the NetBeans-generated code for the GUI. To get the result, click "Connect", then "Query", then "Cancel" before the query finishes (it takes about 12 seconds on my machine, but of course you'll need a database for this - I had to put 1 million unindexed records in before it would run slow enough) - you'll need console output to see this.
The reason things are static is that this was intended to be a quick & dirty program to test a single connection and how to cancel long queries - it was a bit quicker to write a constructor than a factory method which checks whether there's a connection or not. With a non-static class would then be a lot of extra coding to make sure that the database access thread could handle simultaneous queries on different connections, but not on the same one. I'm definitely not calling the constructor more than once (unless I hit the Connect button twice, and even then it doesn't do anything except build a new Connection object which is never used ).
The bits in the log beginning with // are my comments telling you what the preceding line actually meant.
Thanks for your help.
Peter
The calling code follows:
* FrameConnection.java
* Created on 28 September 2006, 12:40
package com.ptoye.TestConnection;
* @author  PToye
public class FrameConnection extends javax.swing.JFrame {
  int queryId=1;
//  final int queryMax=5;
  /** Creates new form FrameConnection */
  public FrameConnection() {
    initComponents();
  /** This method is called from within the constructor to
   * initialize the form.
   * WARNING: Do NOT modify this code. The content of this method is
   * always regenerated by the Form Editor.
  private void initComponents() {                         
    btnConnect = new javax.swing.JButton();
    btnQuery = new javax.swing.JButton();
    btnClose = new javax.swing.JButton();
    btnCancel = new javax.swing.JButton();
    FormListener formListener = new FormListener();
    setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
    setTitle("Test Connections");
    btnConnect.setText("Connect");
    btnConnect.addActionListener(formListener);
    btnQuery.setText("Query");
    btnQuery.addActionListener(formListener);
    btnClose.setText("Close connection");
    btnClose.addActionListener(formListener);
    btnCancel.setText("Cancel");
    btnCancel.addActionListener(formListener);
    org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(getContentPane());
    getContentPane().setLayout(layout);
    layout.setHorizontalGroup(
      layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
      .add(layout.createSequentialGroup()
        .add(80, 80, 80)
        .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
          .add(btnCancel)
          .add(btnClose)
          .add(btnQuery)
          .add(btnConnect))
        .addContainerGap(57, Short.MAX_VALUE))
    layout.linkSize(new java.awt.Component[] {btnCancel, btnClose, btnConnect, btnQuery}, org.jdesktop.layout.GroupLayout.HORIZONTAL);
    layout.setVerticalGroup(
      layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
      .add(layout.createSequentialGroup()
        .addContainerGap()
        .add(btnConnect)
        .add(22, 22, 22)
        .add(btnQuery)
        .add(23, 23, 23)
        .add(btnClose)
        .add(25, 25, 25)
        .add(btnCancel)
        .addContainerGap(58, Short.MAX_VALUE))
    pack();
  // Code for dispatching events from components to event handlers.
  private class FormListener implements java.awt.event.ActionListener {
    public void actionPerformed(java.awt.event.ActionEvent evt) {
      if (evt.getSource() == btnConnect) {
        FrameConnection.this.btnConnectActionPerformed(evt);
      else if (evt.getSource() == btnQuery) {
        FrameConnection.this.btnQueryActionPerformed(evt);
      else if (evt.getSource() == btnClose) {
        FrameConnection.this.btnCloseActionPerformed(evt);
      else if (evt.getSource() == btnCancel) {
        FrameConnection.this.btnCancelActionPerformed(evt);
  private void btnCancelActionPerformed(java.awt.event.ActionEvent evt) {                                         
    boolean cancelledOK=UserConnection.cancelQuery();
    UserConnection.infoMessage("Query "+(queryId-1)+" cancel accepted: "+cancelledOK);
  private void btnCloseActionPerformed(java.awt.event.ActionEvent evt) {                                        
    UserConnection.close();
  private void btnQueryActionPerformed(java.awt.event.ActionEvent evt) {                                        
    doNewQuery();
  private void btnConnectActionPerformed(java.awt.event.ActionEvent evt) {                                          
    new UserConnection();
  void doNewQuery() {
    if (UserConnection.query(this,queryId++)) {
      UserConnection.infoMessage("Start query "+(queryId-1));
    } else {
      UserConnection.infoMessage("Query refused "+(queryId-1));
  void queryEnded(int id, boolean status) {
    UserConnection.infoMessage("Query ended "+id+": "+status);
//    if (queryId<queryMax) doNewQuery();
   * @param args the command line arguments
  public static void main(String args[]) {
    java.awt.EventQueue.invokeLater(new Runnable() {
      public void run() {
        new FrameConnection().setVisible(true);
  // Variables declaration - do not modify                    
  private javax.swing.JButton btnCancel;
  private javax.swing.JButton btnClose;
  private javax.swing.JButton btnConnect;
  private javax.swing.JButton btnQuery;
  // End of variables declaration                  
}