int funktionA(int b) {
  //do something
  return c;
}

int parallel(int d) {
  int e = new Thread(funktionA(d));
  return e;
}

FutureTask<Integer> future1 = new FutureTask<>(new Callable<Integer>() {
  public Integer call() {
    return funktionA(input);
  }
});

FutureTask<Integer> future1 = new FutureTask<>(() -> funktionA(input));

pool.submit( () -> funktionA(input) );

public static <T extends Comparable<T>> ArrayList<T> parallelSort(ArrayList<T> input, int numberOfThreads) {
        if(input.size() <= 1) return input;

        ArrayList<ArrayList<T>> chunks = new ArrayList<>();
        for(int i = 0; i < numberOfThreads; ++i) chunks.add(new ArrayList<>());

        int position = 0;
        while (!input.isEmpty()) {
            chunks.get(position).add(input.remove(0));
            position = (position + 1) % numberOfThreads;
        }

        ExecutorService pool = Executors.newFixedThreadPool(numberOfThreads);
        ArrayList<Future<ArrayList<T>>> futures = new ArrayList<>();
        
        for(ArrayList<T> chunk : chunks) futures.add(pool.submit(() -> sort(chunk)));

        ArrayList<T> results = new ArrayList<>();

        for(Future<ArrayList<T>> future : futures) {
            try {
                results = merge(results, future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

        pool.shutdown();

        return results;
    }

        while (!input.isEmpty()) {
            chunks.get(position).add(input.remove(0));
            position = (position + 1) % numberOfThreads;
        }

int size = input.size();
int chunkSize = size / numberOfThreads;
ArrayList<List<T>> chunks = new ArrayList<>();
for( int i = 0; i < size; i += chunkSize ) chunks.add( input.subList( i, Math.min( i + chunkSize, size ) );