Different result of Thread in loop,how they work in java?

When i create many threads in a for loop,if i take diffierent method,there are diffierent result.

    private List<Future<Integer>> futureList = new ArrayList<>();
    void testThread() throws ExecutionException, InterruptedException {
    ExecutorService executorService = new ThreadPoolExecutor(4, 4, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(100 * 1024));
    for (int i = 0; i < 10000; i++) {
            int finalI = i;
            Future<Integer> future = executorService.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    System.out.println("call ==" + finalI);
                    return finalI;
                }
            });
            doS(future);
            System.out.println("for end ==："+finalI);
        }
        System.out.println("---------====------------");
        executorService.shutdown();
    }

    private void doS(Future<Integer> future) throws ExecutionException, InterruptedException {
        this.futureList.add(future);
    }

the result like this:

for end ==：0
for end ==：1
for end ==：2
call ==0
for end ==：3
call ==1
for end ==：4
call ==4
call ==2
call ==5
call ==3
for end ==：5
for end ==：6

However,if i change the method doS():

    private List<Future<Integer>> futureList = new ArrayList<>();
    @Test
    void testThread() throws ExecutionException, InterruptedException {
        ExecutorService executorService = new ThreadPoolExecutor(4, 4, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(100 * 1024));
        for (int i = 0; i < 10000; i++) {
            int finalI = i;
            Future<Integer> future = executorService.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    System.out.println("call ==" + finalI);
                    return finalI;
                }
            });
            doS(future);
            System.out.println("for end ==："+finalI);
        }
        System.out.println("---------====------------");
        executorService.shutdown();
    }

    private void doS(Future<Integer> future) throws ExecutionException, InterruptedException {
        Integer integer = future.get();
    }

the result changed:

call ==0
for end ==：0
call ==1
for end ==：1
call ==2
for end ==：2
call ==3
for end ==：3
call ==4
for end ==：4
call ==5
for end ==：5
call ==6
for end ==：6

the method of 'doS()' is not belongs to 'executorService',is not a thread menthod,so is the loop will work in order?why they worked in diffierent ways?
Thank you.

The get(future) function causes the thread its called on to wait for the future to finish and return the result. So its turning your multithreaded code into a loop that starts a thread, then waits for it to finish before starting the next thread. Which pretty much eliminates the point of using a thread at all.

Your original version doesn't have a wait, so all the threads are spawned, and will be launched in whatever order the OS decides.

If you need things to happen in a particular order- don't use threads. You can't enforce that. If you're wondering why the first version is happening in random order- its because the OS schedules threads and switches between them whenever it decides is best, and there's no way to order it. They may happen sequentially, or at the same time in different cores/processors, or in any random order. That's one of the things that makes multithreading where threads need to coordinate hard.