[multithreading] the main thread waits for the sub thread to finish executing, and records the way to execute and obtain the execution result (with annotated code and no pit)

Pretend a lot of words , Look directly at the code , Xiaobai is not afraid of comments on each line , It can be modified adaptively

The important thing is to remind , Most multithreads report errors , Or the data is not right , Please check the rejection policy of the thread pool

	//  Atomic counter , Many times, I'm not sure how many times it needs to be executed to prevent errors 
	private static final AtomicInteger atomicInteger = new AtomicInteger(0);

	//  Thread configuration , Blocking queues , The strategy mode is reasonably configured , It can ensure that the thread will not lose data 
	//  Other thread pool parameters , You can modify it according to your needs , If you don't understand the corresponding parameters, you can read another article 
	//【 Multithreading 】ThreadPoolExecutor Like 10000 words source code analysis （ Annotation super detailed ）
	//  Modify the pool size as needed 
    private static final ExecutorService pool = new ThreadPoolExecutor(2, 4,
            1000, TimeUnit.SECONDS,
            new LinkedBlockingDeque<Runnable>(100),
            new ThreadPoolExecutor.CallerRunsPolicy());

	// Future The interface has blocking synchronization , The efficiency of such code will be greatly reduced 
	//  Interface CompletionService  It can solve such problems .
    private static final CompletionService<Integer> completionService = new ExecutorCompletionService<>(pool);

    public static void main(String[] args) {
    
    	//  Start execution 
        System.out.println(new Date());
        // Start timing 

        for (int i = 0; i < 3; i++) {
    
        	//  Counter plus 1
            atomicInteger.getAndIncrement();
            Callable<Integer> callable = ()-> {
    
                //  Sub threads execute business code 
                int num = 1000;
                int s = 0;
                for (int j = 0; j < num; j++) {
    
                    s += j;
                }
                Thread.sleep(2000);
                System.out.println("t Over s =" + s);
                //  Return execution result 
                return s;
            };
            try {
    
            	//  The execution speed is too fast to see the effect , Get some sleep 
                Thread.sleep(2000);
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
            //  Perform tasks 
            completionService.submit(callable);
        }

		//  Get the value of the atomic counter , Loop to get the return value 
        for (int i = 0; i < atomicInteger.get(); i++) {
    
            try {
    
            	// CompletionService  Of take() Method will first return the earliest executed Callable Return value 
            	//  Which task is completed first , Whichever task returns the value first, print it first , Don't wait for the first Callable object .
            	// CompletionService If no task in the interface has been executed 
            	//  be  take(). get()  The method is still blocked .
                Integer s = completionService.take().get();// Two exceptions need to be caught 
                System.out.println("s : " + s);
            }catch (InterruptedException | ExecutionException e){
    
                e.printStackTrace();
            }
        }

		// pool.shutdown();  Close smoothly , New threads are not allowed to join , The running can be closed after running .
		// pool.shutdownNow();  Violent closure . New threads are not allowed to join , And stop directly to the thread in progress .
        pool.shutdown();
        System.out.println(new Date());
    }