Multithreaded quick processing list collection (combined with the use of thread pool)

There is a big one List aggregate , Traversal does some time-consuming operations , Unable to meet the performance requirements , Query log , Although there are many databases and third parties for a single task API request , More time-consuming , But the return efficiency is acceptable , Therefore, multithreading is preferred to process parallel requests, databases and third parties API, Because you have to deal with list Operate on the data to which it belongs , therefore , Thread pool multithreading processing needs to wait for all processing .

Code up ：

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class testList {
    
    public static void main(String [] args) {
    
        List<String> list = new ArrayList<>();
        for (int i = 1; i <= 900; i++) {
    
            list.add("a"+i);
        }
        ExecutorService touchWorker = Executors.newFixedThreadPool(9, Executors.defaultThreadFactory());
        int size = list.size();
        long start=System.currentTimeMillis();
        if (size > 100) {
    
            int batch = size % 100 == 0 ? size / 100 : size / 100 + 1; // take List Set slicing 
            for (int j = 0; j < batch; j++) {
    
                int end = (j + 1) * 100;
                if (end > size) {
    
                    end = size;
                }
                List<String> subList = list.subList(j * 100, end);// Intercept the data of each small fragment   The first is 0-100 And so on 
                touchWorker.execute(()-> sleepTest(subList));// Let the thread pool perform work 
            }
            touchWorker.shutdown();// Close thread pool 
            while (true) {
    
                if (touchWorker.isTerminated()) {
    
                    break;
                }
            }
        } else {
    
            sleepTest(list);
        }
        long end =System.currentTimeMillis();
        System.out.println((end-start)/1000);
    }

    private static void sleepTest(List<String> subList) {
    
        for (String i : subList) {
    
            try {
    
                // The long-running 
                System.out.println("######" + i + "######" + Thread.currentThread().getName());
                Thread.sleep(100);
            } catch (Exception e) {
    
                e.printStackTrace();
            }
        }
    }
}

Execution results ：
A total of time consuming 10s;
As you can see above, let each operation sleep 0.1s, And then it started 9 Threads , The pieces are also divided 9 A movie , So every thread gets 100 Data processing , This is the fastest way , If the fixed thread pool is on 5 A thread , The same operation , Look at the current execution time ：

when 20s, You can also think of , front 5 One processing 500 It's used 10 second , Back 4 Threads handle the rest 400 It also takes time 10 second . Therefore, in the actual work, the number of threads in the thread pool can be dynamically adjusted according to the size of the fragment .

void shutdown()
Start a sequence close , Perform previously submitted tasks , But don't take on new tasks . If closed , The call has no other effect .
Throw out ：SecurityException - If the security manager exists and closes , this ExecutorService It is possible to operate on some threads that do not allow the caller to modify （ Because it doesn't keep RuntimePermission(“modifyThread”)）, Or the security manager checkAccess Method denied access .

boolean isTerminated()
If all tasks have been completed after closing , Then return to true. Note that unless you first call shutdown or shutdownNow, otherwise isTerminated Never for true. return ： If all tasks have been completed after closing , Then return to true.

As for which thread pool to use, you can see the following
Refer to the article

Reference article ：
https://blog.csdn.net/qililong88/article/details/114320641

Introduction and use examples of four common thread pools

Use an infinite thread pool newCachedThreadPool Possible problems

java Multithreading ： Use newFixedThreadPool Method to create a thread pool with a specified number of threads

Sort and collect several multi-threaded segmentation processing list The way to assemble

Java Medium termination （ The destruction ） Thread method