精华内容
下载资源
问答
  • 多线程 读取List

    千次阅读 2015-08-14 16:17:00
    import java.util.ArrayList; import java.util.List; import org.apache.commons.lang3.ArrayUtils;   public class Test_4 { ... * 多线程处理list  *   * @param data 数据li
    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) {</string>
            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;</string>
            private int start;
            private int end;
     
            public HandleThread(String threadName, List<string> data, int start, int end) {</string>
                this.threadName = threadName;
                this.data = data;
                this.start = start;
                this.end = end;
            }
     
            public void run() {
                // TODO 这里处理数据
                data.subList(start, end).add("^&*");
                System.out.println(threadName)
            }
     
        }
     
        public static void main(String[] args) {
            Test_4 test = new Test_4();
            // 准备数据
            List<string> data = new ArrayList<string>();</string></string>
            for (int i = 0; i < 5000; i++) {
                data.add("item" + i);
            }
            test.handleList(data, 5);
            System.out.println(ArrayUtils.toString(data));
        }
    }
    展开全文
  • 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;
    }

    展开全文
  • python多线程读取列表

    千次阅读 2019-08-07 10:09:46
    本文代码实现了python多线程读取列表,包括python多线程初始化、开始和释放线程锁、分配多线程列表数等内容,可做参考。

    说明:

    最近做的项目里要处理百万级数据,单线程跑的时间能把人逼疯,用多线程处理就不可避免了。
    学习多线程期间看到以下这段代码比较清晰明了,所以转载一下。
    本段代码包括python多线程初始化、开始和释放线程锁、分配多线程列表数等内容。
    亲测修改后可用,感谢原博主。

    转载原文地址:均益个人博客 » python 多线程读取列表(可以设置线程数,平均分配每个线程读取的列表数)

    代码:

    # -*- coding: UTF-8 -*-
    import threading
    from time import sleep,ctime
    
    class myThread (threading.Thread):
       def __init__(self, threadID, name, s , e):
           threading.Thread.__init__(self)
           self.threadID = threadID
           self.name = name
           self.s = s
           self.e = e
       def run(self):
           print "Starting " + self.name+ctime()
          # 获得锁,成功获得锁定后返回True
          # 可选的timeout参数不填时将一直阻塞直到获得锁定
          # 否则超时后将返回False
           threadLock.acquire()
           #线程需要执行的方法
           printImg(self.s,self.e)
           # 释放锁
           threadLock.release()
    
    listImg = [] #创建需要读取的列表,可以自行创建自己的列表
    for i in range(179):
       listImg.append(i)
    
    # 按照分配的区间,读取列表内容,需要其他功能在这个方法里设置
    def printImg(s,e):
       for i in range(s,e):
           print i
    
    
    totalThread = 3 #需要创建的线程数,可以控制线程的数量
    
    lenList = len(listImg) #列表的总长度
    gap = lenList / totalThread #列表分配到每个线程的执行数
    
    threadLock = threading.Lock() #锁
    threads = [] #创建线程列表
    
    # 创建新线程和添加线程到列表
    for i in range(totalThread):
       thread = 'thread%s' % i
       if i == 0:
           thread = myThread(0, "Thread-%s" % i, 0,gap)
       elif totalThread==i+1:
           thread = myThread(i, "Thread-%s" % i, i*gap,lenList)
       else:
           thread = myThread(i, "Thread-%s" % i, i*gap,(i+1)*gap)
       threads.append(thread) # 添加线程到列表
    
    # 循环开启线程
    for i in range(totalThread):
       threads[i].start()
    
    # 等待所有线程完成
    for t in threads:
       t.join()
    print "Exiting Main Thread"
    

    若要求多线程返回子线程结果,则可参考文章:python多线程处理数据并获得子线程返回值

    展开全文
  • java 多线程读取多个文件

    千次阅读 2019-01-02 10:49:34
    package ... import java.io.*; import java.util.List; import java.util.concurrent.CountDownLatch; ... * 多线程读取多个文件 */ public class FileThread extends Thread{ p...

    工具类代码如下:

    import java.io.*;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    
    /**
     * 多线程读取多个文件
     */
    public class FileThread extends Thread{
    
        private final CountDownLatch countDownLatch = new CountDownLatch(10);
        private int fileIndex;
        private List<String> filelist;
        private String filepath = "D:\\LocalFtpServer\\data20181229\\";
        private String movepath = "D:\\LocalFtpServer\\data20181229_01\\";
    
        public int getFileIndex() {
            return fileIndex;
        }
    
        public void setFileIndex(int fileIndex) {
            this.fileIndex = fileIndex;
        }
    
        public List<String> getFilelist() {
            return filelist;
        }
    
        public void setFilelist(List<String> filelist) {
            this.filelist = filelist;
        }
    
        @Override
        public void run() {
    
            for (int i = 0; i < filelist.size(); i++) {
                if (i % 10 == fileIndex) {
                    //读取文件
                    File readfile = new File(filepath + filelist.get(i));
                    InputStreamReader isr = null;
                    try {
                        isr = new InputStreamReader(new FileInputStream(readfile), "UTF-8");
                        BufferedReader reader = new BufferedReader(isr);
                        String line = null;
                        // 一次读入一行,直到读入null为文件结束
                        while ((line = reader.readLine()) != null) {
                            System.out.println(line );
                        }
                        reader.close();
                        isr.close();
                    } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    //读取完后, 移动文件位置
                    readfile.renameTo(new File(movepath + readfile.getName()));
                }
            }
            countDownLatch.countDown();
        }
    }
    
    

    调用测试:

     public static void main(String[] args) throws IOException {
    			String filepath = "D:\\LocalFtpServer\\data20181229\\";
    			File file = new File(filepath);
    			//读取目录下所有文件
    			String[] filelist = file.list();
    			List<String> fList=new ArrayList<String>();
    
    			for (int i = 0; i < filelist.length; i++) {
    				if (filelist[i].startsWith("data") && filelist[i].endsWith(".txt")) {
    					fList.add(filelist[i]);
    				}
    			}
    			for(int i=0;i<30;i++){
    				FileThread fileThread=new FileThread();
    				fileThread.setFileIndex(i);
    				fileThread.setFilelist(fList);
    				fileThread.start();
    			}
    			countDownLatch.await();
    }
    
    展开全文
  • Python开启多线程读取pdf

    千次阅读 2018-04-11 23:27:52
    # 开启多线程写文件 t_list = [] for file_path in need_files: t = threading.Thread(target=parse,args=(file_path,)) t.start() t_list.append(t) # 设置主线程等待所有子线程完成之后在执行 for ...
  • 多线程读取大数据文件

    千次阅读 2014-01-06 21:01:17
    工作之故,要读取一个几十万条的文本,就写了这个程序,倒腾了俩天,并不一定是最终版,姑且先记录下来。 1、本地读取以后改为网络读取 ...5、基于线程安全考虑,HashMap可能改为ConcurrentHashMap import
  • TensorFlow多线程读取机制

    千次阅读 2018-09-21 11:08:07
    1、TensorFlow读取机制图解  我们必须要把数据先读入后才能进行计算,假设读入用时0.1s,计算用时0.9s,那么就意味... 读取线程源源不断地将文件系统中的图片读入到一个内存的队列中,而负责计算的是另一个线程,...
  • 文件上传-队列多线程读取文件内容

    千次阅读 2016-08-22 18:25:59
    队列多线程读取文件内容 为什么采用多线程队列的方式呢?主要是如果文件一行一行读取处理的话,页面上传文件后,需要等待服务器响应。如果文件的内容数据量很大的话,页面就一直等待服务器响应,毕竟服务器处理这些...
  • 如果全部采用单线程的话效率过低,无法接受,因此考虑多线程并发处理。期间踩了好多坑。小伙伴们应该很好奇效率到底差多少,贴一下实验数据。/** * 单线程读取300w数据库时间为 15s 添加链表中总时长17s * 四...
  • JAVA使用多线程读取超大文件

    千次阅读 2014-12-11 17:07:51
    在读取超过10G的文件时会发现一次读一行的速度实在是不能接受,想到使用多线程+FileChannel来做一个使用多线程版本。 基本思路如下: 1.计算出文件总大小 2.分段处理,计算出每个线程读取文件的开始与结束...
  • 现有网上的资料良莠不齐,写的不够清晰,对于初学者而言,很难实现高性能读取habse数据,自己整合资料,耗费一个多星期,完成了hbase高性能读取数据,当然本程序依旧有很大的优化空间,java多线程这一个点就是值得...
  • Java 大文本多线程高效读取

    千次阅读 2017-07-04 10:59:55
    本文介绍 Java多线程读取大文件性能提升的高效方案。 前沿 我们在读取一个正常文件的时候,将使用,BufferedReader.read() 的三种方法: BufferedReader.read() 单字节,这个效率最低,基本不考了 ...
  • 利用多线程读取数据加快网络训练

    千次阅读 2018-06-15 16:12:30
    http://manutdzou.github.io/2017/11/27/multiprocee-data-generator.html利用多线程生成数据当CPU读取数据跟不上GPU处理数据速度时候可以考虑这种方式,这种方法的好处是数据接口简单而且可以大幅加快网络训练时间...
  • java多线程批量读取文件(一)

    万次阅读 2017-04-25 10:22:03
    新公司入职一个多月了,至今没有事情可以做,十来个新同事都一样抓狂...而今天,我所要说的是java多线程读取文件的两个例子; 例子1:java多线程批量读取文件 package face.thread.ReadFile; /**  * 多线程读、写文件
  • 多线程中,一个线程负责不断(20Ms左右)的删除LIST中的数据,然后不断的添加数据,另一个UI线程负责隔一段时间(300ms左右)来读取数据显示。list中添加的数据不能是结构体,否则很容易报错,加锁也不行,很快...
  • } } 2、编写一个测试类执行多线程 package com.toycloud.awaken.platform; import com.toycloud.awaken.platform.service.AsyncService; import org.junit.Test; import org.junit.runner.RunWith; import org....
  • 多线程读取IP摄像头(Python版)

    千次阅读 2019-07-19 19:08:41
    如果我们碰到了一个实时性要求不是那么高的,或者自己设备太差处理不过来图像时,我们可以考虑使用多线程读取摄像头画面!比如我们现在需要两个线程,一个用于实时读取视频流,另外一个每隔一秒钟处理一个最新的...
  • QT中使用GDAL多线程读取遥感图像到QImage

    万次阅读 热门讨论 2010-03-26 12:17:00
    GDAL 是一个很强大的可以读取格式 的带有GIS信息的栅格型图像。前阵子项目中需要读取遥感图像,并显示到QT界面,由于遥感图像一般很大,所以采取新开一个读图线程的方式来读取,防止界面假死。下面是代码共享,...
  • 线程安全:就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全:就是不提供...
  • 多线程读取或写入,一般会涉及到同步的问题,否则产生的结果是无法预期的。那么在读取一个文件的时候,我们可以通过加锁,但读不像写操作,会导致文件错误,另外锁操作是有一定的耗时。因此通过文件分块,可以比较...
  • 多线程分段读取数据库

    千次阅读 2014-10-24 18:24:56
    有这样一个需求,线程
  • JAVA实现多线程分段读取文件

    千次阅读 2019-11-15 09:32:18
    2:为每个线程分配读取行数 分配算法:略平均分配 线程数 文件总行数 线程分配的行数 2 10 thread1 = 5,thread2 = 5 2 9 thread1 = 4,thread2 = 5 3 10 thread1 = 3,thread...
  • 现在想利用多线程读取一个文件夹中的多个xml文件,但是现在每个线程都把所有文件全部读一遍,我希望的是一个线程读过的文件,其他线程就不去读了,请问我的代码错在什么地方?本人新手,多谢! ps:我也试过每读一...
  • 多线程读写分离
  • Python 多线程分块读取文件

    千次阅读 2018-08-14 17:45:31
    读取配置文件 ''' config = ConfigParser.ConfigParser() config.readfp(open('conf.ini')) #文件名 file_name = config.get('info', 'fileName') #线程数量 thread_num = int(config.get('info', '...
  • Java 中List集合使用多线程分段处理

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 179,013
精华内容 71,605
关键字:

多线程读取list