code: private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                                boolean timed, long nanos)
          throws InterruptedException, ExecutionException, TimeoutException {
          if (tasks == null)
              throw new NullPointerException();
          int ntasks = tasks.size();
          if (ntasks == 0)
              throw new IllegalArgumentException();
          ArrayList<Future<T>> futures = new ArrayList<>(ntasks);
          ExecutorCompletionService<T> ecs =
              new ExecutorCompletionService<T>(this);
  
          // For efficiency, especially in executors with limited
          // parallelism, check to see if previously submitted tasks are
          // done before submitting more of them. This interleaving
          // plus the exception mechanics account for messiness of main
          // loop.
  
          try {
              // Record exceptions so that if we fail to obtain any
              // result, we can throw the last exception we got.
              ExecutionException ee = null;
              final long deadline = timed ? System.nanoTime() + nanos : 0L;
              Iterator<? extends Callable<T>> it = tasks.iterator();
  
              // Start one task for sure; the rest incrementally
              futures.add(ecs.submit(it.next()));
              --ntasks;
              int active = 1;
  
              for (;;) {
                  Future<T> f = ecs.poll();
                  if (f == null) {
                      if (ntasks > 0) {
                          --ntasks;
                          futures.add(ecs.submit(it.next()));
                          ++active;
                      }
                      else if (active == 0)
                          break;
                      else if (timed) {
                          f = ecs.poll(nanos, NANOSECONDS);
                          if (f == null)
                              throw new TimeoutException();
                          nanos = deadline - System.nanoTime();
                      }
                      else
                          f = ecs.take();
                  }
                  if (f != null) {
                      --active;
                      try {
                          return f.get();
                      } catch (ExecutionException eex) {
                          ee = eex;
                      } catch (RuntimeException rex) {
                          ee = new ExecutionException(rex);
                      }
                  }
              }
  
              if (ee == null)
                  ee = new ExecutionException();
              throw ee;
  
          } finally {
              cancelAll(futures);
          }
      }
docs: the main mechanics of invokeAny.