精华内容
下载资源
问答
  • 2021-02-12 10:51:57

    本文实例为大家分享了java多线程读取多个文件的具体代码,供大家参考,具体内容如下

    工具类代码如下:

    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 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 getFilelist() {

    return filelist;

    }

    public void setFilelist(List 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 fList=new ArrayList();

    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();

    }

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    更多相关内容
  • 多线程 读取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多线程下的list

    千次阅读 2020-12-22 11:05:33
    多线程下的 list安全 or 不安全? 不安全!通常我们说的线程安全是指针对某个数据结构的所有操作都是线程安全,在这种定义下,Python 常用的数据结构 list,dict,str等都是线程不安全的尽管多线程下的li...

    list 是 Python 常用的几个基本数据类型之一.正常情况下我们会对 list 有增删改查的操作,显然易见不会有任何问题.那么如果我们试着在多线程下操作list 会有问题吗?

    多线程下的 list

    安全 or 不安全? 不安全!

    通常我们说的线程安全是指针对某个数据结构的所有操作都是线程安全,在这种定义下,Python 常用的数据结构 list,dict,str等都是线程不安全的

    尽管多线程下的list是线程不安全的,但是在 append的操作下是它又是线程安全的.

    如何判断线程安全呢?

    对于线程安全不安全,我们可以通过极端条件下去复现,从而得出结论。比如说判断 list是否线程安全

    import threading

    import time

    # 随意设置 count 的值,值越大错误抛出的越快

    count = 1000

    l = []

    def add():

    for i in range(count):

    l.append(i)

    time.sleep(0.0001)

    def remove():

    for i in range(count):

    l.remove(i)

    time.sleep(0.0001)

    t1 = threading.Thread(target=add)

    t2 = threading.Thread(target=remove)

    t1.start()

    t2.start()

    t1.join()

    t2.join()

    print(l)

    有时候一次运行并不一定就会出错,多次重试之后会出现类似下面的错误

    很显然这种操作方式不具有普适性,如果要是欧气太强,说不定会一直不出现异常。

    那么出了这种方式,有没有比较简单有效的方法吗?答案是有的

    dis

    dis 库是 Python 自带的一个库,可以用来分析字节码。这里我们需要有这样的认识,字节码的每一行都是一个原子操作,多线程切换就是以原子操作为单位的,如果一个操作需要两行字节码就说明它是线程不安全的

    remove

    这里我们先看一下上面 list 的 remove 操作

    >>> import dis

    >>> def test_remove():

    ... a = [1]

    ... a.remove(0)

    ...

    >>> dis.dis(test_remove)

    2 0 LOAD_CONST 1 (1)

    2 BUILD_LIST 1

    4 STORE_FAST 0 (a)

    3 6 LOAD_FAST 0 (a)

    8 LOAD_ATTR 0 (remove)

    10 LOAD_CONST 2 (0)

    12 CALL_FUNCTION 1

    14 POP_TOP

    16 LOAD_CONST 0 (None)

    18 RETURN_VALUE

    从上面不难看出,整个 remove 操作被分成了好几条指令,这就意味着在多线程情况下会出现错乱的情况,试想一下,如果多线程下都去 remove 列表的话,并且不按照顺序,很容易出现问题。

    append

    在最上面我们说到,list 的append操作是线程安全的,那么究竟是为什么呢?我们同样来用 dis 查看一下

    8 19 LOAD_GLOBAL 0 (a)

    22 LOAD_ATTR 2 (append)

    25 LOAD_CONST 2 (1)

    28 CALL_FUNCTION 1

    31 POP_TOP

    这里显然,append 也是有几条指令,势必在多线程执行的情况下也会发生交错,但是对于多线程下我们操作append, 我们肯定也不会在乎这个时候 list到顺序问题了,所以我们说它的 append 是线程安全的

    参考

    以上就是详解Python多线程下的list的详细内容,更多关于Python多线程下的list的资料请关注脚本之家其它相关文章!

    展开全文
  • Java多线程读取文件

    2021-08-16 18:48:52
    } } } 多线程读取文件列表 import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; import redis.clients.jedis.Jedis; import java.io.*; ...
  • python多线程读取列表

    千次阅读 2019-08-07 10:09:46
    本文代码实现了python多线程读取列表,包括python多线程初始化、开始和释放线程锁、分配多线程列表数等内容,可做参考。
  • cur_path).result() #data_frame_list.append(single_data_frame) all_task.append(task) except: print("Error: 读取异常") wait(all_task) for future in as_completed(all_task): result = future.result() data...
  • 从单个机械磁盘并行读取实际上比使用单个线程读取要慢,因为实际上,当每个线程轮到运行时,您将机械磁头弹回到磁盘的不同部分.这最好保留为单线程活动.让我们再举一个例子,它与你的类似,但实际上可以提供一些好处:...
  • 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...
  • 在读取超过10G的文件时会发现一次读一行的速度实在是不能接受,想到使用多线程+FileChannel来做一个使用多线程版本。基本思路如下:1.计算出文件总大小2.分段处理,计算出每个线程读取文件的开始与结束位置(文件大小/...
  • 现有网上的资料良莠不齐,写的不够清晰,对于初学者而言,很难实现高性能读取habse数据,自己整合资料,耗费一个多星期,完成了hbase高性能读取数据,当然本程序依旧有很大的优化空间,java多线程这一个点就是值得...
  • } } 复制代码 Task类 提供一个简单的思路: 1、读取出来的数据处理过后存入数据库[写在run方法里就行] package ThreadLearning; import java.util.List; /** * @author kyojurorengoku * @date 2022/1/20 * @...
  • 多线程快速导入大量数据到mysql

    千次阅读 2022-03-28 14:29:00
    批量导入3w条数据需要一分多钟,最终使用多线程分批导入mysql中,将时间压缩到10s以内。 网上比较好的方法就是下面这种,但是这种方式比较繁琐,我们可以根据自己的情况来优化。 二、多线程分批导入Mysql @...
  • } } 2、编写一个测试类执行多线程 package com.toycloud.awaken.platform; import com.toycloud.awaken.platform.service.AsyncService; import org.junit.Test; import org.junit.runner.RunWith; import org....
  • C#多线程处理List集合数据

    千次阅读 2022-01-27 08:44:29
    List集合是非线程安全的,所以我们采用并行编程时会发生错误。如下图所示 Parallel.For(0, 1000, (i) => { Product product = new Product(); product.Name = "name" + i; product.Category = "Category" ...
  • 多线程读取IP摄像头(Python)

    千次阅读 2020-12-04 01:41:52
    多线程处理摄像头读取 如果我们碰到了一个实时性要求不是那么高的,或者自己设备太差处理不过来图像时,我们可以考虑使用多线程读取摄像头画面!比如我们现在需要两个线程,一个用于实时读取视频流,另外一个每隔...
  • Java多线程并发中支持并发的list对象

    千次阅读 2021-03-08 16:59:50
    Java多线程并发编程中并发容器第二篇之List的并发类讲解概述本文我们将详细讲解list对应的并发容器以及用代码来测试ArrayList、vector以及CopyOnWriteArrayList在100个线程向list中添加1000个数据后的比较本文是...
  • C# 多线程更新LiST的问题

    千次阅读 2020-05-26 21:49:22
    多线程中,一个线程负责不断(20Ms左右)的删除LIST中的数据,然后不断的添加数据,另一个UI线程负责隔一段时间(300ms左右)来读取数据显示。list中添加的数据不能是结构体,否则很容易报错,加锁也不行,很快...
  • 多线程读取IP摄像头(Python版)

    千次阅读 2019-07-19 19:08:41
    如果我们碰到了一个实时性要求不是那么高的,或者自己设备太差处理不过来图像时,我们可以考虑使用多线程读取摄像头画面!比如我们现在需要两个线程,一个用于实时读取视频流,另外一个每隔一秒钟处理一个最新的...
  • 这些队列都实现了锁原语,能够在多线程中直接使用。可以使用队列来实现线程间的同步。 常用方法: Queue.qsize() 返回队列的大小 Queue.empty() 如果队列为空,返回True,反之False Queue.full() 如果队列满了,返回...
  • 多线程List 如何解决不安全问题

    千次阅读 2020-07-14 14:04:40
    线程安全:就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全:就是不提供...
  • 从Mongo里多线程取数据,我一开始尝试了用Executors.newFixedThreadPool线程池来实现。实际操作中,发现只有第一个线程会正常取数据,后建立的线程访问Mongo的cursor会报错。 后来改变了实现方式,通过Thread.start...
  • 如果全部采用单线程的话效率过低,无法接受,因此考虑多线程并发处理。期间踩了好多坑。小伙伴们应该很好奇效率到底差多少,贴一下实验数据。/** * 单线程读取300w数据库时间为 15s 添加链表中总时长17s * 四...
  • 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...
  • java多线程批量读取文件(一)

    万次阅读 2017-04-25 10:22:03
    新公司入职一个多月了,至今没有事情可以做,十来个新同事都一样抓狂...而今天,我所要说的是java多线程读取文件的两个例子; 例子1:java多线程批量读取文件 package face.thread.ReadFile; /**  * 多线程读、写文件
  • 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 ...
  • 判断文件夹是否存在 if (!FileHelper.IsExistDirectory(prg.DirectoryPath)) return false;...多线程并行读取文件数据 ConcurrentDictionary<string, AttendModel> list = new ConcurrentDi..
  • SpringBoot--多线程处理

    千次阅读 2021-07-31 00:38:02
    原文网址:SpringBoot--多线程处理_IT利刃出鞘的博客-CSDN博客 简介 为什么需要多线程 项目里经常会遇到这样的场景: 读一次数据库的某个表 遍历这些数据,对每一个数据,都以它为条件再次查其他表 将第二步查到的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 204,307
精华内容 81,722
关键字:

多线程读取list