Future.isCancelled and thread interruption

[Pushkar N Kulkarni]

"Future.cancel(true)" cancels the receiver Future and also attempts to interrupt the executor thread that is running this task. However, not all threads may be interrupted. An exception are threads that executing one of the "restart-able blocking system calls" from libnet.  
Such threads will ignore the thread interrupt(EINTR) and restart the blocking system call that was interrupted. See the system calls wrapped in the BLOCKING_IO_RETURN_INT macro: https://github.com/openjdk/jdk/blob/master/src/java.base/linux/native/libnet/linux_close.c#L352


The javadoc for "java.util.concurrent.Future.cancel(boolean mayInterruptIfRunning)" DOES clarify that this method is an "attempt" to cancel the Future, and that it has no effect if the "task is already completed or cancelled, or could not be cancelled for *some other reason*". It is also made clear that "the return value from this method does not necessarily indicate whether the task is now cancelled". This is good, in the context of this note.

The javadoc also presents "Future.isCancelled()" as a definitive way to test if a Future was cancelled. However, it does not comment on the thread interruption attempted by Future.cancel(true). This might lead users to assume that if "Future.isCancelled()" returns true, the related executor thread was also successfully interrupted. This assumption would be invalid if the related executor thread was blocked in one of libnet's restart-able system calls (connect() could block for a couple of minutes). 

I am attaching a test program that reproduces the mentioned behaviour. The executor thread held a lock and it was assumed that when "Future.isCancelled()" returned true, the executor had been interrupted and the lock released. In reality, the lock was held for a longer time and it blocked the main thread where the invalid assumption was made. 

I am curious to know what others think of this matter! Any help/corrections/opinions will be appreciated. Thank you!

----------
import java.net.*;
import java.util.concurrent.*;

public class ConnectionTest {
    private  synchronized Socket connect(String host, int port) throws Exception {
        InetSocketAddress address = new InetSocketAddress(host, port);
        Socket s = new Socket();
        s.connect(address); // HERE: s.connect(address, T), with any T>0, would resolve the hang!
        return s;
    }

    private Socket connectToMain() throws Exception {
        System.out.println("Connecting to main...");
        return connect("www.google.com", 81);
    }

    private Socket connectToAlternate() throws Exception {
        System.out.println("Connecting to alternate...");
        return connect("www.example.com", 80);
    }

    public void test() throws Exception {
        ExecutorService es = Executors.newFixedThreadPool(1);
        Future<Socket> f = es.submit(new Callable<Socket>() {
            public Socket call() throws Exception {
                return connectToMain();
            }
        }); 
        try {
            f.get(2000, TimeUnit.MILLISECONDS);
            System.out.println("Connected to main!");
            return;
        } catch (TimeoutException e) {
            System.out.println("Connection to main timed out, cancelling the Future with mayInterruptIfRunning = true");
            boolean ret = f.cancel(true);
            System.out.println("Future.cancel(true) returned " + ret);
        }
        System.out.println("Is Future canceled? ..." + f.isCancelled());
        if (f.isCancelled()) {
            connectToAlternate();
            System.out.println("Connected to alternate!");
        }
    }

    public static void main(String [] args) throws Exception {
        new ConnectionTest().test();
    }
}
----------

-Pushkar