Page History

Threads and tasks that block on operations involving network or file I/O must provide callers with an explicit termination mechanism to prevent denial-of-service (DoS) vulnerabilities.

Noncompliant Code Example (Blocking I/O, Volatile Flag)

This noncompliant code example uses a volatile done flag to indicate that it whether is safe to shut down the thread, as suggested in rule THI05-J. Do not use Thread.stop() to terminate threads. However, when the thread is blocked on network I/O as a consequence of invoking the readLine() method, it cannot respond to the newly - set flag until the network I/O is complete. Consequently, thread termination may be indefinitely delayed.

Code Block

bgColor	#FFcccc


// Thread-safe class 
public final class SocketReader implements Runnable { 
  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
  @Override 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(); // Shut Shutdowndown the thread
  }
}

Noncompliant Code Example (Blocking I/O, Interruptible)

This noncompliant code example is similar to the preceding example but uses thread interruption to shut down the thread. Network I/O on a java.net.Socket is unresponsive to thread interruption.

Code Block

bgColor	#FFcccc


// Thread-safe class 
public final class SocketReader implements Runnable { 
  // otherOther methods...

  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
  }
}

...

This compliant solution terminates the blocking network I/O by closing the socket in the shutdown() method. The readLine() method throws a SocketException when the socket is closed, consequently allowing the thread to proceed. Note that it is impossible to keep the connection alive while simultaneously halting the thread both cleanly and immediately.

Code Block

bgColor	#ccccff


public final class SocketReader implements Runnable {
  // otherOther methods...

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

  public void shutdown() throws IOException {
    socket.close();
  }

  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();
  }
}

...

When additional operations must be performed after emerging from the blocked state, use a boolean flag to indicate pending termination. When supplementing the code with such a flag, the shutdown() method should also set the flag to false so that the thread can cleanly exit from the while loop.

Compliant Solution (Interruptible Channel)

This compliant solution uses an interruptible channel, java.nio.channels.SocketChannel, instead of a Socket connection. If the thread performing the network I/O is interrupted using the Thread.interrupt() method while it is reading the data, the thread receives a ClosedByInterruptException, and the channel is closed immediately. The thread's interrupted status is also set.

Code Block

bgColor	#ccccff


public final class SocketReader implements Runnable {
  private final SocketChannel sc;
  private final Object lock = new Object();

  public SocketReader(String host, int port) throws IOException {
    sc = SocketChannel.open(new InetSocketAddress(host, port));
  }

  @Override public void run() {
    ByteBuffer buf = ByteBuffer.allocate(1024);
    try {
      synchronized (lock) {
        while (!Thread.interrupted()) {
          sc.read(buf);
          // ...
        }
      }
    } catch (IOException ie) {
      // Forward to handler
    }
  }

  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();
  }
}

This technique interrupts the current thread. However, it stops the thread only because the code polls the thread's interrupted status with the Thread.interrupted() method and terminates the thread when it is interrupted. Using a SocketChannel ensures that the condition in the while loop is tested as soon as an interruption is received, even though the read is normally a blocking operation. Similarly, invoking the interrupt() method of a thread blocked on a java.nio.channels.Selector also causes that thread to awaken.

...

This noncompliant code example shows a thread-safe DBConnector class that creates one JDBC connection per thread. Each connection belongs to one thread and is not shared by other threads. This is a common use case because JDBC connections are intended to be single-threaded.

Code Block

bgColor	#FFcccc


public final class DBConnector implements Runnable {
  private final String query;

  DBConnector(String query) {
    this.query = query;
  }

  @Override 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();
  }
}

...

This compliant solution uses a ThreadLocal wrapper around the connection so that a thread calling the initialValue() method obtains a unique connection instance. This approach allows provision of a cancelStatement() so that other threads or clients can interrupt a long-running query when required. The cancelStatement() method invokes the Statement.cancel() method.

Code Block

bgColor	#ccccff


public final class DBConnector implements Runnable {
  private final String query;
  private volatile Statement stmt;

  DBConnector(String query) {
    this.query = query;
  }

  private static final if (getConnection() != null) {ThreadLocal<Connection> connectionHolder = 
      try {
        stmt = getConnection().createStatement();
      } catch (SQLException e) {
        // Forward to handler
 new ThreadLocal<Connection>() {
   }
 Connection connection = }null;
  }

  private static final@Override ThreadLocal<Connection>public connectionHolderConnection =initialValue() {
      try {
        // ...
        connection = DriverManager.getConnection(
             new ThreadLocal<Connection>() {"jdbc:driver:name", 
    Connection connection = null;

    @Override public Connection initialValue() {
"username", 
        try {
   "password"
     // ...
  );
      connection} =catch DriverManager.getConnection(
SQLException e) {
        //  "jdbc:driver:name", Forward to handler
      }
      "username", return connection;
    }
  };

  public Connection   "password"getConnection() {
        return connectionHolder.get();
  }

  public boolean } catch (SQLException ecancelStatement() {
 // Allows client to cancel statement
    //Statement ForwardtmpStmt to= handlerstmt;
    if (tmpStmt  }!= null) {
      returntry connection;{
      }
  }tmpStmt.cancel();

  public Connection getConnection() {
    return connectionHolder.get()true;
  }

  public boolean } catch cancelStatement(SQLException e) {
        // Allows clientForward to cancel statementhandler
    if (stmt !=}
 null) {
  }
    tryreturn {false;
  }

  @Override public void  stmt.cancelrun(); {
    try {
   return  true;
 if (getConnection()    } catch (SQLException e!= null) {
        // Forward to handler
      }
    }
    return false;
  }

  @Override public void run() {
stmt = getConnection().createStatement();
     try {}
       if (stmt == null || (stmt.getConnection() != getConnection())) {
        throw new IllegalStateException();
      }
      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);
    connector.cancelStatement();
  }
}

...

According to the Java API, interface Interface Statement documentation [API 20062014]

By default, only one ResultSet object per Statement object can be open at the same time. As a result, if the reading of one ResultSet object is interleaved with the reading of another, each must have been generated by different Statement objects.

...

Failure to provide facilities for thread termination can cause nonresponsiveness and DoS.

Rule	Severity	Likelihood	Remediation Cost	Priority	Level
THI04-J	low Low	probable Probable	medium Medium	P4	L3

Bibliography

24.3, Stopping a Thread

[API 20062014]	Class `Thread`, method `stop`, interface `ExecutorService` Interface `ExecutorService` Interface `Statement`
[Darwin 2004]	Section 24.3, "Stopping a Thread"
[Goetz 2006]	Chapter 7, "Cancellation and Shutdown"
[JavaThreads 2004]	Section 2.4, "Two Approaches to Stopping a Thread"	[Darwin 2004]
[JDK7 2008]	Java Thread Primitive Deprecation
[JPL 2006]	Section 14.12.1, "Don't Stop; " Section 23.3.3, "Shutdown Strategies"
[JavaThreads 2004]	2.4, Two Approaches to Stopping a Thread
[Goetz 2006]	Chapter 7, Cancellation and Shutdown

...

Image Added Image Added Image Removed 09. Thread APIs (THI) Image Modified

Space shortcuts

Page tree

Versions Compared

Old Version 87

New Version Current

Key

Noncompliant Code Example (Blocking I/O, Volatile Flag)

Noncompliant Code Example (Blocking I/O, Interruptible)

Compliant Solution (Interruptible Channel)

Bibliography