Page History

 

{code:bgColor=#FFcccc}
public final class SocketReader implements Runnable { // Thread-safe class
  private final Socket socket;
  private final BufferedReader in;
  private volatile boolean done = false;
  private final Object lock = new Object();

  public SocketReader(String host, int port) throws IOException {
    this.socket = new Socket(host, port);
    this.in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
  }
  
  // Only one thread can use the socket at a particular time
  public void run() {
    try {
      synchronized (lock) {
        readData(); 
      }      
    } catch (IOException ie) {
      // Forward to handler
    }
  }

  public void readData() throws IOException {
    String string;
    while (!done && (string = in.readLine()) != null) {
      // Blocks until end of stream (null)
    }
  }

  public void shutdown() {
    done = true;
  }

  public static void main(String[] args) throws IOException, InterruptedException {
    SocketReader reader = new SocketReader("somehost", 25);
    Thread thread = new Thread(reader);
    thread.start();
    Thread.sleep(1000);
    reader.shutdown(); // Shutdown the thread
  }
}
{code}


h2. Noncompliant Code Example (blocking IO, interruptible)

 

{code:bgColor=#FFcccc}
public final class SocketReader implements Runnable { // Thread-safe class
  // ...
  
  public void readData() throws IOException {
    String string;
    while (!Thread.interrupted() && (string = in.readLine()) != null) { 
      // Blocks until end of stream (null)
    }
  }
  
  public static void main(String[] args) throws IOException, InterruptedException {
    SocketReader reader = new SocketReader("somehost", 25);
    Thread thread = new Thread(reader);
    thread.start();
    Thread.sleep(1000); 
    thread.interrupt(); // Interrupt the thread
  }
}
{code}


h2. Compliant Solution (close socket connection)

 

{code:bgColor=#FFcccc}
public final class DBConnector implements Runnable {
  private final String query;
  
  DBConnector(String query) {
    this.query = query; 
  }
	
  public void run() {
    Connection connection;
    try {
      // Username and password are hard coded for brevity
      connection = DriverManager.getConnection("jdbc:driver:name", "username", "password");  
      Statement stmt = connection.createStatement();
      ResultSet rs = stmt.executeQuery(query);
      // ...
    } catch (SQLException e) {
      // Forward to handler
    }
    // ... 
  }  

  public static void main(String[] args) throws InterruptedException {
    DBConnector connector = new DBConnector("suitable query");
    Thread thread = new Thread(connector);
    thread.start();
    Thread.sleep(5000);
    thread.interrupt();
  }
}
{code}

public final class DBConnector implements Runnable {
  private final String query;
  
  DBConnector(String query) {
    this.query = query;
  }
	
  private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
    Connection connection = null;

    @Override public Connection initialValue() {		
      try {
        // Username and password are hard coded for brevity
        connection = DriverManager.getConnection
          ("jdbc:driver:name", "username", "password");  	    	      
      } catch (SQLException e

Unfortunately database connections, like sockets, are not inherently interruptible. Consequently, this design does not permit a client to cancel a task by closing the resource if the corresponding thread is blocked on a long running activity such as a join query. 

{mc}Not sure what to do with the following text. ~DS :
Other than helping thread cancellation, a mechanism to close connections also prevents thread starvation because threads can be allowed to fairly share the limited number of database connections available in the pool. A similar mechanism is required for task cancellation when using socket objects that are local to a method. {mc}


h2. Compliant Solution (ThreadLocal)

This compliant solution uses a {{ThreadLocal}} wrapper around the connection so that a thread that calls {{initialValue()}} obtains a unique connection instance. The advantage of this approach is that a {{shutdownConnection()}} method can be provided so that clients external to the class can also close the connection when the corresponding thread is blocked, or is performing some time consuming activity.

{code:bgColor=#ccccff}
public final class DBConnector implements Runnable {
  private final String query;
  
  DBConnector(String query) {
    this.query = query;
  // Forward to handler
      }}
	
  private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
    Connection connection return= connection;
    }
		null;

    @Override public voidConnection setinitialValue(Connection con) {		
      if(connection == null) { // Shuts down connection when con = null		       try {
        // Username and password are hard coded for brevity
        try {connection = DriverManager.getConnection
          connection.close();
  ("jdbc:driver:name", "username", "password");  	    	      
      } catch (SQLException e) {
          // Forward to handler
 
     }
    }	  return connection;
    }
		
    @Override public void set(Connection con) {
      } else {
        connection = con; 
      }
if(connection == null) { // Shuts down connection when con = null		       
       }
 try };
{
  public static Connection getConnection() {
    return connectionHolderconnection.getclose();
  }

  public static void shutdownConnection( } catch (SQLException e) {
          // AllowsForward clientto tohandler close
 connection anytime
    connectionHolder.set(null);
  }

	  public void run() {
  		  Connection dbConnection = getConnection();
  
  Statement stmt;
   } tryelse {
      stmt  connection = dbConnection.createStatement();		
con; 
      }
  ResultSet  rs}
 = stmt.executeQuery(query); };

  public static }Connection catch getConnection(SQLException e) {
    return  // Forward to handler	 
    }    connectionHolder.get();
  }

  public static void shutdownConnection() { // Allows client to close connection anytime
    // ...connectionHolder.set(null);
  }

  public static void mainrun(String[] args) throws InterruptedException {
    DBConnectorConnection connectordbConnection = new DBConnector("suitable query"getConnection();
    Statement Threadstmt;
  thread = new Thread(connector);try {
    thread.start  stmt = dbConnection.createStatement();		
      ResultSet rs Thread= stmt.sleepexecuteQuery(5000query);
      // connector.shutdown();
  }
}