Java 多线程处理集合数据

处理一个包含10万条数据的字符串集合，将其中含有'4599'的字符串都返回。

1.开启线程代码如下：

import com.baidu.model.ConCallable; 
import com.baidu.model.PropertiesTest; 
import com.google.common.collect.ImmutableList; 
import com.google.common.util.concurrent。*; 
导入org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.RequestMethod; 
import org.springframework.web.bind.annotation.RestController; 

import java.util.ArrayList; 
import java.util.List; 
import java.util.concurrent.CountDownLatch; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.TimeUnit; 

/ **多线程，线程池使用类
 *由Mypc于2018/3/21 0021创建。
 * / 
@RestController 
@RequestMapping（“thread”）
public class ThreadController { 

    private Logger logger = LoggerFactory.getLogger（org.slf4j.Logger.class）; 

    @RequestMapping（value =“test1”，method = RequestMethod.GET）
    public String test1（）{ 
        ExecutorService executorService = null; 
        try { 
            // 10万条数据
            List <String> list = new ArrayList <>（）; 
            List <String> list2 = new ArrayList <>（）; 

            for（int i = 1; i <= 100000; i ++）{ 
                list.add（“test：”+ i）;




            int count = list.size（）/ size; 
            if（count * size！= list.size（））{ 
                count ++; 
            } 
            int countNum = 0; 
            //线程计数器
            final CountDownLatch countDownLatch = new CountDownLatch（count）; 
            //初始化一个定长线程池对象
            executorService = Executors.newFixedThreadPool（8）; 
            //监听线程池
            ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator（executorService）; 
            while（countNum <list.size（））{ 
                countNum + = size; 
                //创建线程任务
                ConCallable callable = new ConCallable（）;
                //分列400份）的数据，分给不同线程处理
                callable.setList（ImmutableList.copyOf（list.subList（countNum - size，countNum <list.size（）？countNum：list.size（））） ）; 
                ListenableFuture listenableFuture = listeningExecutorService.submit（callable）; 
                Futures.addCallback（listenableFuture，new FutureCallback <List <String >>（）{ 
                    @Override 
                    public void onSuccess（List <String> list1）{ 
                        countDownLatch.countDown（）; 
                        // list1为返回值
                        list2.addAll（list1）; 
                    } 

                    @Override 
                    public void onFailure（Throwable throwable）{
                        countDownLatch.countDown（）; 
                        logger.info（ “处理出错：”，抛出）; 
                    } 
                }）; 
            } 
            countDownLatch.await（30，TimeUnit.MINUTES）; 
            logger.info（ “符合条件的返回数据个数为：” + list2.size（））; 
            logger.info（ “回调函数：” + list2.toString（））; 
        catch（Exception e）{ 
            e.printStackTrace（）; 
        } finally { 
            //关闭资源
            executorService.shutdown（）; 
        } 
        return“正在处理......”;

    }

2.线程任务类代码：

/ ** 
 *由Mypc于2018/3/21 0021创建。
 * / 
public class ConCallable implements Callable { 

    private List <String> list; 

    @Override 
    public Object call（）抛出异常{ 
        List listRe = new ArrayList（）; 
        for（int i = 0; i <list.size（）; i ++）{ 
            //含有'4599'的字符串都返回
            if（list.get（i）.contains（“4599”））{ 
                listRe.add list.get（I））; 
            } 
        } 
        return listRe; 
    } 

    public List <String> getList（）{ 
        return list; 
    } 

    public void setList（List <String> list）{ 
        this.list = list; 
    } 
}