Question

java 定义一个线程池 循环遍历list，进行读写操作

因为遍历list过程中的操作比较费时，遍历一次需要15秒左右，所以要用到线程池，而且需要同步，不会读取重复，但是不知道怎么写，求大神帮助！

Answer 1

import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 并发处理器
 * 适用于如下场景（举例）：
 * 一个任务队列， 有150个任务需要并发处理，使用此对象，可以每次并发执行20次（可设置），则总共串行执行8次并发，可获取执行结果
 *
 * @param <T> 类型T限制为任务Callable使用的数据对象和返回结果的数据对象为同一个bean
 */
public class ConcurrentExcutor<T>
{
    /** 非空，所有任务数组 */
    private Callable<T>[] tasks;
    
    /** 非空，每次并发需要处理的任务数 */
    private int numb;
    
    /** 可选，存放返回结果，这里有个限制，泛型T必须为Callable返回的类型T */
    private List<T> result;
    
    /**
     * 无参构造
     */
    public ConcurrentExcutor()
    {
        super();
    }

    /**
     * 不需要返回结果的任务用此创建对象
     * @param tasks
     * @param numb
     */
    public ConcurrentExcutor(Callable<T>[] tasks, int numb)
    {
        super();
        this.tasks = tasks;
        this.numb = numb;
    }

    /**
     * 需要结果集用此方法创建对象
     * @param tasks
     * @param numb
     * @param result
     */
    public ConcurrentExcutor(Callable<T>[] tasks, int numb, List<T> result)
    {
        super();
        this.tasks = tasks;
        this.numb = numb;
        this.result = result;
    }

    public void excute()
    {
        // 参数校验
        if(tasks == null || numb < 1)
        {
            return;
        }
        
        // 待处理的任务数
        int num = tasks.length;
        if(num == 0)
        {
            return;
        }
        
        // 第一层循环，每numb条数据作为一次并发
        for(int i=0; i<(int)Math.floor(num/numb) + 1; i++)
        {
            // 用于记录此次numb条任务的处理结果
            Future[] futureArray;
            if(numb > num)
            {
                futureArray = new Future[num];
            }
            else
            {
                futureArray = new Future[numb];
            }
            
            // 创建线程容器
            ExecutorService es = Executors.newCachedThreadPool();
            
            // 第二层循环，针对这numb条数据进行处理
            for(int j=i*numb; j<(i+1)*numb; j++)
            {
                // 如果超出数组长度，退出循环
                if(j + 1 > num)
                {
                    break;
                }
                // 执行任务，并设置Future到数组中
                futureArray[j%numb] = es.submit(tasks[j]);
            }
            
            // 将结果放入result中
            if (result != null)
            {
                for (int j = 0; j < futureArray.length; j++)
                {
                    try
                    {
                        if(futureArray[j] != null)
                        {
                            Object o = futureArray[j].get();
                            result.add((T)o);
                        }
                    }
                    catch (InterruptedException e)
                    {
                        System.out.println("处理Future时发生InterruptedException异常，目标Future为： " + futureArray[j].toString());
                        e.printStackTrace();
                    }
                    catch (ExecutionException e)
                    {
                        System.out.println("处理Future时发生ExecutionException异常，目标Future为： " + futureArray[j].toString());
                        e.printStackTrace();
                    }
                }
            }
            
            es.shutdown();
        }
    }

追问

for (int i = 0; i < list.size(); i++) {
new Thread( "" + i) {
String id = list.getId();
public void run() {
test part =info(id);
}
}.start();
}
我以前是直接遍历一次就建一个线程，你给的这个我也不知道怎么去调用，

追答

你这样直接循环list不太好，如果list有1000条数据，你瞬间就起了一千个线程，而且需要人为写代码注意同步问题。你这个代码最严重的问题是，子线程处理结果你主线程要拿到很麻烦，这一点在真正项目应用中很重要！

我发给你的那段代码我测过可以用的，大概调用思路就是：

1. 把你“遍历一次需要15秒左右”这个事情写到一个类里面，类实现Callable<T>接口，

   这个我们称之为一个任务

2. 然后你不是有个List吗，遍历这个list，构建一个任务数组

3. 创建ConcurrentExcutor对象并执行数组里面的任务

下面是我自己项目中的调用代码，供你参考（ProcessNumTask就是那个实现Callable的任务）：

ProcessNumTask[] tasks = new ProcessNumTask[tempList.size()];

        for(int i=0; i<tempList.size(); i++)

        {

            tasks[i] = new ProcessNumTask(tempList.get(i));

        }

        ConcurrentExcutor<ReportProcessInfo> ce = new ConcurrentExcutor<ReportProcessInfo>(tasks, 5, result);

        ce.excute();