關於Java多線程處理List數據

一、背景

多線程數量的問題，一般情況下，多線程數量要等於機器CPU核數-1。

 

二、實例

1、解決問題：如何讓n個線程順序遍歷含有n個元素的List集合

import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.ArrayUtils;

public class Test_4 {
    /**
     * 多線程處理list
     *
     * @param data  數據list
     * @param threadNum  線程數
     */
    public synchronized void handleList(List<String> data, int threadNum) {
        int length = data.size();
        int tl = length % threadNum == 0 ? length / threadNum : (length
                / threadNum + 1);

        for (int i = 0; i < threadNum; i++) {
            int end = (i + 1) * tl;
            HandleThread thread = new HandleThread("線程[" + (i + 1) + "] ",  data, i * tl, end > length ? length : end);
            thread.start();
        }
    }

    class HandleThread extends Thread {
        private String threadName;
        private List<String> data;
        private int start;
        private int end;

        public HandleThread(String threadName, List<String> data, int start, int end) {
            this.threadName = threadName;
            this.data = data;
            this.start = start;
            this.end = end;
        }

        public void run() {
            List<String> subList = data.subList(start, end)/*.add("^&*")*/;
            System.out.println(threadName+"處理了"+subList.size()+"條！");
        }

    }

    public static void main(String[] args) {
        Test_4 test = new Test_4();
        // 准備數據
        List<String> data = new ArrayList<String>();
        for (int i = 0; i < 6666; i++) {
            data.add("item" + i);
        }
        test.handleList(data, 5);
        System.out.println(ArrayUtils.toString(data));
    }
}

 

2、List多線程並發讀取讀取現有的list對象

//測試讀取List的線程類，大概34秒
package com.thread.list;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        Map<Long,Integer> map = new HashMap<Long,Integer>();

        for(int i = 0;i<1000;i++){
            list.add(""+i);
        }

        int pcount = Runtime.getRuntime().availableProcessors();
        long start = System.currentTimeMillis();

        for(int i=0;i<pcount;i++){

           Thread t = new MyThread1(list,map);
            map.put(t.getId(),Integer.valueOf(i));
            t.start();
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
           // System.out.println(list.get(i));
        }
        System.out.println("----"+(System.currentTimeMillis() - start));
    }
}

//線程類
package com.thread.list;

import java.util.List;
import java.util.Map;

public class MyThread1 extends Thread {

    private List<String> list;
    private Map<Long,Integer> map;

    public MyThread1(List<String> list,Map<Long,Integer> map){
        this.list = list;
        this.map = map;
    }

    @Override
    public void run() {

        int pcount = Runtime.getRuntime().availableProcessors();
        int i = map.get(Thread.currentThread().getId());

        for(;i<list.size();i+=pcount){
            System.out.println(list.get(i));
        }
    }
}

 

3、多線程分段處理List集合

場景：大數據List集合，需要對List集合中的數據同標准庫中數據進行對比，生成新增，更新，取消數據。

解決方案:

a、List集合分段；

b、動態創建線程池newFixedThreadPool；

c、將對比操作在多線程中實現；

public static void main(String[] args) throws Exception {

        // 開始時間
        long start = System.currentTimeMillis();
        List<String> list = new ArrayList<String>();

        for (int i = 1; i <= 3000; i++) {
            list.add(i + "");
        }
        // 每500條數據開啟一條線程
        int threadSize = 500;
        // 總數據條數
        int dataSize = list.size();
        // 線程數
        int threadNum = dataSize / threadSize + 1;
        // 定義標記,過濾threadNum為整數
        boolean special = dataSize % threadSize == 0;

        // 創建一個線程池
        ExecutorService exec = Executors.newFixedThreadPool(threadNum);
        // 定義一個任務集合
        List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>();
        Callable<Integer> task = null;
        List<String> cutList = null;

        // 確定每條線程的數據
        for (int i = 0; i < threadNum; i++) {
            if (i == threadNum - 1) {
                if (special) {
                    break;
                }
                cutList = list.subList(threadSize * i, dataSize);
            } else {
                cutList = list.subList(threadSize * i, threadSize * (i + 1));
            }
            // System.out.println("第" + (i + 1) + "組：" + cutList.toString());
            final List<String> listStr = cutList;
            task = new Callable<Integer>() {

                @Override
                public Integer call() throws Exception {
                    System.out.println(Thread.currentThread().getName() + "線程：" + listStr);
                    return 1;
                }
            };
            // 這里提交的任務容器列表和返回的Future列表存在順序對應的關系
            tasks.add(task);
        }

        List<Future<Integer>> results = exec.invokeAll(tasks);

        for (Future<Integer> future : results) {
            System.out.println(future.get());
        }

        // 關閉線程池
        exec.shutdown();
        System.out.println("線程任務執行結束");
        System.err.println("執行任務消耗了 ：" + (System.currentTimeMillis() - start) + "毫秒");
    }