public interface CancellableTask<T> extends Callable<T>{
    
    
  void cancel();
  RunnableFuture<T> newTask();
}

public class CancellingExecutor extends ThreadPoolExecutor{
    
    
 ...
 protected<T> RunnableFuture<T> newTaskFor(Callable<T> callable){
    
    
   if(callable instanceof CancellableTask){
    
    
     return (CancellableTask<T>).newTask();
   }else{
    
    
     return super.newTaskFor(callable);
   }
 }
}

public abstract class SocketUsingTask<T> implements CancellableTask<T>{
    
    
  private Socket socket;
  
  public synchronized void setSocket(Socket s){
    
    
    socket = s;
  }

  public synchronized void cancel(){
    
    
    try{
    
    
      if(socket != null){
    
    
        socket.close();
      }
    }catch(IOException ignored){
    
    }
  }
  
  public RunnableFuture<T> newTask(){
    
    
    return new FutureTask<T>(this){
    
    
      public boolean cancel(boolean mayInterruptIfRunning){
    
    
        try{
    
    
          SocketUsingTask.this.cancel();
        }finally{
    
    
          return super.cancel(mayInterruptIfRunning);
        }
      }
    }
  }
}