精华内容
下载资源
问答
  • 主要介绍了Python多线程下的list的相关资料,文中示例代码非常详细,帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 主要介绍了Java多线程处理List数据,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 需求:使用多线程来处理同一个List中的数据,希望每线程处理的数量是均匀的 事例代码如下: public class Test { static class HandleThread extends Thread { private String threadName; private List&...

    需求:使用多线程来处理同一个List中的数据,希望每个线程处理的数量是均匀的

    事例代码如下:

    public class Test {
        static class HandleThread extends Thread {
            private String threadName;
            private List<String> list;
            private int startIndex;
            private int endIndex;
    
            public HandleThread(String threadName, List<String> list, int startIndex, int endIndex) {
                this.threadName = threadName;
                this.list = list;
                this.startIndex = startIndex;
                this.endIndex = endIndex;
            }
    
            public void run() {
                List<String> subList = list.subList(startIndex, endIndex);
                System.out.println(threadName+"处理了"+subList.size()+"条!startIndex:"+startIndex+"|endIndex:"+endIndex);
            }
    
        }
    
        public static void main(String[] args) {
            Test test = new Test();
            List<String> tmpList = new ArrayList<String>();
            for (int i = 0; i < 120; i++) {
                tmpList.add("test" + i);
            }
    
            int length = tmpList.size();
            int num = 10; //初始线程数
    
            //启动多线程
            if(num > length){
                num = length;
            }
            int baseNum = length / num;
            int remainderNum = length % num;
            int end  = 0;
            for (int i = 0; i < num; i++) {
                int start = end ;
                end = start + baseNum;
                if(i == (num-1)){
                    end = length;
                }else if( i < remainderNum){
                    end = end + 1;
                }
                HandleThread thread = new HandleThread("线程[" + (i + 1) + "] ",  tmpList,start , end);
                thread.start();
            }
        }
    }

    控制台输出如下:

    展开全文
  • java 多线程处理一个list的集合

    万次阅读 2016-08-03 09:16:20
    import java.util.ArrayList;...import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    public class App {
    	public static final String module = App.class.getName();
    
    	public static void main(String[] args) {
    
    		try {
    			List<String> list = new ArrayList<>();
    			for (int i = 0; i < 100; i++) {
    				list.add(i + ",");
    			}
    
    			System.out.println(new App().list2Str(list, 5));
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	public String list2Str(List<String> list, final int nThreads)
    			throws Exception {
    		if (list == null || list.isEmpty()) {
    			return null;
    		}
    		StringBuffer ret = new StringBuffer();
    
    		int size = list.size();
    		ExecutorService executorService = Executors.newFixedThreadPool(nThreads);
    		List<Future<String>> futures = new ArrayList<Future<String>>(nThreads);
    		for (int i = 0; i < nThreads; i++) {
    			final List<String> subList = list.subList(size / nThreads * i, size/ nThreads * (i + 1));
    			Callable<String> task = new Callable<String>() {
    				@Override
    				public String call() throws Exception {
    					StringBuffer sb = new StringBuffer();
    					for (String str : subList) {
    						sb.append(str);
    					}
    					return sb.toString();
    				}
    			};
    			futures.add(executorService.submit(task));
    		}
    
    		for (Future<String> future : futures) {
    			ret.append(future.get());
    		}
    		executorService.shutdown();
    
    		return ret.toString();
    	}<span id="transmark"></span>
    
    }
    

    如果您喜欢我写的博文,读后觉得收获很大,不妨小额赞助我一下,让我有动力继续写出高质量的博文,感谢您的赞赏!!!


    展开全文
  • 我已经用C++写好了一个List类,现在想实现下多线程操作List,要求同步增加数据,同时把数据写入同一文件中。小白枚,求大牛指导。。。
  • java多线程读取、操作List集合

    千次阅读 2018-05-21 16:36:00
    /** * 固定开辟8线程 * * @Author: wpf * @Date: 16:05 2018/5/21 * @Description: * @param * @param null * @return */ private void threadExec1(List&lt;SysCompany&g...

    大数据中,多线程分段list操作, demo如下

    /**
     * 每500条数据开启一条线程
     *
     * @Author: wpf
     * @Date: 16:05 2018/5/21
     * @Description: 
     * @param  * @param null  
     * @return   
     */
    private void threadExec2(List<SysCompany> list) throws ExecutionException, InterruptedException {
        // 开始时间
        long start = System.currentTimeMillis();
    
        LOG.info("list的大小:" + list.size());
    
        // 每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<SysCompany>> tasks = new ArrayList<Callable<SysCompany>>();
        Callable<SysCompany> task = null;
        List<SysCompany> 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));
            }
            // LOG.info("第" + (i + 1) + "组:" + cutList.toString());
            final List<SysCompany> listStr = cutList;
            task = new Callable<SysCompany>() {
    
                @Override
                public SysCompany call() throws Exception {
                    for(SysCompany c : listStr){
                        if(StringUtils.isNotEmpty(c.getUsername())){
                            LOG.info("timer:在执行中..." + c.getUsername());
                            // 业务...
                            sysCompanyService.getComCodeByInfoCompanyUser(c.getUsername());
                        }
                    }
                    return null;
                }
            };
            // 这里提交的任务容器列表和返回的Future列表存在顺序对应的关系
            tasks.add(task);
        }
        List<Future<SysCompany>> results = exec.invokeAll(tasks);
        /*for (Future<SysCompany> future : results) {
            SysCompany c = future.get();
        }*/
        // 关闭线程池
        exec.shutdown();
        LOG.info("线程任务执行结束");
        LOG.info("执行任务消耗了 :" + (System.currentTimeMillis() - start) + "毫秒");
    }
    
    
    /**
     * 固定开辟8线程
     *
     * @Author: wpf
     * @Date: 16:05 2018/5/21
     * @Description:
     * @param  * @param null
     * @return
     */
    private void threadExec1(List<SysCompany> list) throws ExecutionException, InterruptedException{
        // 开始时间
        long start = System.currentTimeMillis();
    
        // 总数据条数
        int listSize = list.size();
        LOG.info("总记录数为:"+listSize);
        // 线程数
        int threadNum = 8;
    
        // 创建一个线程池
        ExecutorService exec = Executors.newFixedThreadPool(threadNum);
        // 定义一个任务集合
        List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>();
        Callable<Integer> task = null;
        List<SysCompany> cutList = null;
    
        // 均分算法
        Map<Integer,Long> map = allotOfAverage1(threadNum,listSize);
        int endValue = 0;
        int startValue = 0;
        int i = 0;
        for (Long v : map.values()) {
            endValue = (int)(startValue+v);
            cutList = list.subList(startValue, endValue);
            startValue += v;
            LOG.info("第" + ++i +"组大小为:"+cutList.size());
            final List<SysCompany> listStr = cutList;
            task = new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    for(SysCompany c : listStr){
                        if(StringUtils.isNotEmpty(c.getUsername())){
    
                            // LOG.info("timer:在执行中..." + c.getUsername());
                            // 业务...
                            sysCompanyService.getComCodeByInfoCompanyUser(c.getUsername());
                        }
                    }
                    return 1;
                }
            };
            // 这里提交的任务容器列表和返回的Future列表存在顺序对应的关系
            tasks.add(task);
        }
    
        List<Future<Integer>> results = exec.invokeAll(tasks);
        for (Future<Integer> future : results) {
            LOG.info(future.get());
        }
        // 关闭线程池
        exec.shutdown();
        LOG.info("线程任务执行结束");
        LOG.info("执行任务消耗了 :" + (System.currentTimeMillis() - start) + "毫秒");
    }
    /*
     * 平均分配
     */
    public static Map<Integer,Long> allotOfAverage1(int threadNum, long listSize){
        Map<Integer,Long> allot=new HashMap<Integer,Long>(); //保存分配的信息
        for(int i=0;i<listSize;i++){
            int j=i%threadNum;
            if(allot.containsKey(j)){
                allot.put(j, allot.get(j) +1);
            }else{
                allot.put(j, 1L);
            }
        }
        return allot;
    }

    展开全文
  • 1.错误示例(多个线程同时操作同一个List对象,List线程不安全) import com.alibaba.fastjson.JSONObject; import java.util.*; import java.util.concurrent.CountDownLatch; public class Main { public ...
    1. 多个子线程执行结果插入List集合

    1.错误示例(多个线程同时操作同一个List对象,List是线程不安全)

    import com.alibaba.fastjson.JSONObject;
    
    import java.util.*;
    import java.util.concurrent.CountDownLatch;
    
    public class Main {
        public static void main(String[] args) throws InterruptedException {
            List<Object> list = new ArrayList<>();
    
            //CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后,
            //再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。
            // 当每一个线程完成自己任务后,计数器的值就会减一。
            // 当计数器的值为0时,表示所有的线程都已经完成一些任务,
            // 然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务
            int threadCount = 10000;
            CountDownLatch latch = new CountDownLatch(threadCount);
            for (int i = 0; i < threadCount; i++) {
                int finalI = i;
                new Thread(new Runnable() {
                    JSONObject json = new JSONObject();
    
                    @Override
                    public void run() {
                        json.put("i", finalI);
                        list.add(json);
                        //计数器减一
                        latch.countDown();
                    }
                }).start();
            }
            //阻塞当前线程,直到计数器的值为0
            latch.await();
            System.err.println(list.size());
        }
    }

    执行结果 <10000 

     2.正确示例

     解决方案

    1.使用Vector,是一个线程安全的List,但是它的线程安全实现方式是对所有操作都加上了synchronized关键字,这种方式严重影响效率.所以并不推荐使用Vector
    2.使用 Collections.synchronizedList(List list),可以将add()等方法的时候是加synchronized关键字的,但是iterator()却没有加.所以在遍历使用的时候需要加上synchronized

    import com.alibaba.fastjson.JSONObject;
    
    import java.util.*;
    import java.util.concurrent.CountDownLatch;
    
    public class Main {
        public static void main(String[] args) throws InterruptedException {
            //Vector list = new Vector();
            List<Object> list = Collections.synchronizedList(new ArrayList<>());
    
            //CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后,
            // 再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。
            // 当每一个线程完成自己任务后,计数器的值就会减一。
            // 当计数器的值为0时,表示所有的线程都已经完成一些任务,
            // 然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务
            int threadCount = 10000;
            CountDownLatch latch = new CountDownLatch(threadCount);
            for (int i = 0; i < threadCount; i++) {
                int finalI = i;
                new Thread(new Runnable() {
                    JSONObject json = new JSONObject();
    
                    @Override
                    public void run() {
                        json.put("i", finalI);
                        list.add(json);
                        //计数器减一
                        latch.countDown();
                    }
                }).start();
            }
            //阻塞当前线程,直到计数器的值为0
            latch.await();
            System.err.println(list.size());
        }
    }
    

    执行结果 10000

     

    知识点:

    CountDownLatch:https://www.jianshu.com/p/e233bb37d2e6

    展开全文
  • C实现的多线程(pthread)安全链表数据结构 包括member, insert, delete, traverse基本操作 编译时需要链接pthread库,如 gcc -O3 SortList2.c -lpthread
  • 多线程处理List数据

    千次阅读 2018-11-04 17:26:35
    CountDownLatch进行多线程处理list 由于公司的一个辅算系统进行计算的时间比较长3万的数据需要5分钟才能算完这完全超出了预算,我跟负责项目的同事交流之后发现代码的if 语句特别多导致臃肿等等。针对这些先了几点...
  • 线程处理1个List集合

    千次阅读 2014-04-03 16:38:38
    昨天发了一个提问,启动5个线程一个List中的内容,然后将5个线程的内容拼接起来,由于时间比较急迫,自己就写了一个Demo,希望对菜鸟有参考意义。。 [code="java"] import java.util.ArrayList; ...
  • 多线程同一个excel文件(导出)

    千次阅读 2018-03-22 15:14:17
    最近一个excel导出的任务让我搞了好久,想想踩过的坑,就想上来小结一番。 ------------------------------------------------------分割线------------------------------------------------------   ...
  • Java多线程并发中支持并发的list对象

    千次阅读 2021-03-08 16:59:50
    Java多线程并发编程中并发容器第二篇之List的并发类讲解概述本文我们将详细讲解list对应的并发容器以及用代码来测试ArrayList、vector以及CopyOnWriteArrayList在100线程向list中添加1000数据后的比较本文是...
  • 多线程中,一个线程负责不断(20Ms左右)的删除LIST中的数据,然后不断的添加数据,另一个UI线程负责隔段时间(300ms左右)来读取数据显示。list中添加的数据不能是结构体,否则很容易报错,加锁也不行,很快...
  • 获取导入excel文件中的数据,存入list中进行多线程处理,设定每线程处理多少条数据,进行设定值动态启动线程数量数据,根据线程处理 数量拆分动态list数据进行相关业务操作 package com.ig.bi.game.controller; ...
  • c++ 多线程通过list传递数据
  • 【Python】多线程下的list

    千次阅读 2020-07-03 09:10:40
    那么如果我们试着在多线程操作list 会有问题吗? 多线程下的 list 安全 or 不安全? 不安全! 通常我们说的线程安全是指针对某个数据结构的所有操作都是线程安全,在这种定义下,Python 常用的数据结构 list,dict,...
  • 多线程处理List并将结果合并

    千次阅读 2021-02-21 20:07:10
    开始打算使用@Async 异步多线程操作。后面发现在合并操作结果的时候没有思路。 查找相关资料以后,使用了Callable和Future解决了问题。 2.相关知识点: Callable接口定义了方法public T call() throws ...
  • 先看示例代码1 using System; using System.Collections.Generic; using System.Threading; namespace CollSecExp { class Program { static void Main(string[] args) {
  • Java 中List集合使用多线程分段处理

    千次阅读 2018-12-12 10:45:31
    因业务需要,需从excel读取数据并插入数据库,由于数据量较大,耗时较长,考虑使用多线程来处理 1.读取到的list按数据量分段 2.动态创建线程 public class ScmcommissionLineServiceImpl{ //导入数据 public ...
  • 多线程处理List集合

    千次阅读 2020-06-30 11:52:30
    我会编写一个多线程方案改善你的代码。 实施方案 将集合拆分成多子集合,数据分片 引入三方,guava <dependency> <groupId>com.google.guava</groupId> <artifactId>guava<...
  • List<String> list = new ArrayList(); for (int i = 0; i ; i++) { list.add(i + ""); } ExecutorService exec = Executors.newFixedThreadPool(3); CountDownLatch doneSignal = new CountDownLatch(3); ...
  • 多线程操作一个对象

    千次阅读 2018-10-18 14:04:51
    1.extends Thread,这方法建立多线程,每线程就是自定义的类的对象,所以每线程对应一个对象,没有对同一个对象操作。如果想对同一个对象操作,需要把对象作为一个属性,传递进去。不过,这对象只能是引用...
  • 多线程处理一个list的集合

    千次阅读 2015-05-13 10:26:12
    import java.util.ArrayList; import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;
  • //只是很简单的实现了数据集,数据集的操作服务类,多线程模拟多生产者和多消费者。最后一个测试类。 多生产者多消费者。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 405,220
精华内容 162,088
关键字:

多线程操作同一个list