精华内容
下载资源
问答
  • 主要为大家详细介绍了java多线程有序读取一个文件,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要为大家详细介绍了java多线程读取个文件的方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 今天遇到一个问题,需要多个...首先我们写个文件,然后多线程读取,以下是我实验的代码:package com.alibaba.middleware.race;import java.io.IOException; import java.io.RandomAccessFile;public class Test2 { pub

    今天遇到一个问题,需要多个线程读取同一个文件的不同位置,提高效率,写代码验证了一下,把结果记录下来。

    首先我们写个文件,然后多线程读取,以下是我实验的代码:

    package com.alibaba.middleware.race;
    
    import java.io.IOException;
    import java.io.RandomAccessFile;
    
    public class Test2 {
    
        public static void main(String[] args) throws IOException {
            byte[] th1 = "线程1".getBytes();
            byte[] th2 = "线程2".getBytes();
            byte[] th3 = "线程3".getBytes();
            final int len = th1.length;
    
            final RandomAccessFile raf = new RandomAccessFile(
                    "F:/tianchi/index.data", "rw");
            raf.seek(1);
            raf.write(th1);
            raf.seek(200);
            raf.write(th2);
            raf.seek(300);
            raf.write(th3);
    
            Runnable runnable1 = new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        byte[] b = new byte[len];
                        try {
                            raf.seek(1);
                            raf.read(b);
    
                            if ("线程1".equals(new String(b))) {
                                System.out.println("ok");
                            } else {
    
                                System.out.println("线程1-" + new String(b));
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
    
                    }
                }
            };
            Runnable runnable2 = new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            byte[] b = new byte[len];
                            raf.seek(200);
                            raf.read(b);
                            if ("线程2".equals(new String(b))) {
                                System.out.println("ok");
                            } else {
    
                                System.out.println("线程2-" + new String(b));
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            Runnable runnable3 = new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            byte[] b = new byte[len];
                            raf.seek(300);
                            raf.read(b);
                            if ("线程3".equals(new String(b))) {
                                System.out.println("ok");
                            } else {
    
                                System.out.println("线程3-" + new String(b));
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
    
            for (int i = 0; i < 20; i++) {
                new Thread(runnable1).start();
                new Thread(runnable2).start();
                new Thread(runnable3).start();
            }
            System.out.println("主线程完了");
    
        }
    
    }
    

    测试结果如下,会出现这样的问题:

    ok
    线程3-
    线程1-线程3
    ok
    ok

    说明,多个线程读取同一个文件,不加锁,是会出错的。
    然后我们做如下改进。

    代码:

    package com.alibaba.middleware.race;
    
    import java.io.IOException;
    import java.io.RandomAccessFile;
    
    public class Test2 {
    
        public static void main(String[] args) throws IOException {
            byte[] th1 = "线程1".getBytes();
            byte[] th2 = "线程2".getBytes();
            byte[] th3 = "线程3".getBytes();
            final int len = th1.length;
    
            final RandomAccessFile raf = new RandomAccessFile(
                    "F:/tianchi/index.data", "rw");
            raf.seek(1);
            raf.write(th1);
            raf.seek(200);
            raf.write(th2);
            raf.seek(300);
            raf.write(th3);
    
            Runnable runnable1 = new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        byte[] b = new byte[len];
                        try {
                            synchronized (raf) {
                                raf.seek(1);
                                raf.read(b);
                            }
    
                            if ("线程1".equals(new String(b))) {
                                System.out.println("ok");
                            } else {
    
                                System.out.println("线程1-" + new String(b));
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
    
                    }
                }
            };
            Runnable runnable2 = new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            byte[] b = new byte[len];
                            synchronized (raf) {
                                raf.seek(200);
                                raf.read(b);
                            }
                            if ("线程2".equals(new String(b))) {
                                System.out.println("ok");
                            } else {
    
                                System.out.println("线程2-" + new String(b));
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            Runnable runnable3 = new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            byte[] b = new byte[len];
                            synchronized (raf) {
                                raf.seek(300);
                                raf.read(b);
                            }
                            if ("线程3".equals(new String(b))) {
                                System.out.println("ok");
                            } else {
    
                                System.out.println("线程3-" + new String(b));
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
    
            for (int i = 0; i < 20; i++) {
                new Thread(runnable1).start();
                new Thread(runnable2).start();
                new Thread(runnable3).start();
            }
            System.out.println("主线程完了");
    
        }
    
    }

    对文件的访问加一个锁,这样就可以了,测试结果是对的,我就不贴了。

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

    万次阅读 2015-05-13 21:36:05
    python多线程读取一个文件 多线程读取一个文件,要求不能重复,不能遗漏。 最开始尝试了一种方法(后来实践证明是无效的) 主线程分配给每个读线程需要读取文件中哪些, 比如线程1读取1-10,线程2...

    python多线程读取同一个文件

    多线程读取同一个文件,要求不能重复,不能遗漏。


    最开始尝试了一种方法(后来实践证明是无效的)

    主线程分配给每个读线程需要读取文件中哪些行,

    比如线程1读取1-10行,线程2读取11-30行。

    然后每个线程通过readline()来读取,读到的行如果不属于本线程的范围,则continue跳过。

    实践证明,这若干个线程并没有按照我们期望来读。

    我的猜想是,通过open来打开一个文件,多个线程返回的是同一个句柄,

    或者一个文件的文件指针只有一个。

     

    经过网上搜索和实践,总结出有以下方法支持多线程读取同一个文件。

    通过队列Queue来实现。主线程启动一个线程来读文件,把文件的内容放到队列里。

    然后启动若干线程,全部从队列取数据。python中的Queue是线程安全的。

    http://stackoverflow.com/questions/18781354/is-iterating-over-a-python-file-object-thread-safe

    Is iterating over a Python file object thread safe?

     

    通过linecache来实现。linecache可以指定行号来读取一个文件的任意一行。主线程先分配给每个读线程各自读取的行号,然后各线程根据行号用linecache来读取。

    此种方法依赖于linecache读取任意一行的速度,如果是大文件,则比较慢。

    比如线程1需要读取10-20行。假设线程1有自己的文件指针的话,读了地10行,可以直接很快定位到第11行。但是用linecache读取的话,每一次读取一行就没有什么关系了。当然,对于linecache怎么定位到任意一行,其中的原理我也没探究过。

     

    3分文件读取。python先调用linux命令headtail,将一个文件分成若干个文件。然后每个读线程负责读取一个文件即可。


    展开全文
  • 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();
    }
    
    展开全文
  • 多线程读取个文件package thread;import java.io.File; import java.io.IOException; import java.io.RandomAccessFile; import java.util.concurrent.CountDownLatch;public class ReadMultiFilesByThread { /** ...

    多线程读取多个文件

    package thread;
    
    import java.io.File;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    import java.util.concurrent.CountDownLatch;
    
    public class ReadMultiFilesByThread {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            long startTime = System.currentTimeMillis();
    
            final int thNum = 4;
            final String filePath3 = "C:\\Users\\IBM_ADMIN\\Downloads\\马达加斯加3全篇英文台词3.txt"; //266M
            final String filePath2 = "C:\\Users\\IBM_ADMIN\\Downloads\\马达加斯加3全篇英文台词2.txt"; //186M
            final String filePath = "C:\\Users\\IBM_ADMIN\\Downloads\\马达加斯加3全篇英文台词.txt"; //39KB
            final String filePath4 = "C:\\Users\\IBM_ADMIN\\Downloads\\carootcert(1).der"; //1KB
    
            CountDownLatch doneSignal = new CountDownLatch(thNum);
            ReadFileThread2 r1 = new ReadFileThread2(doneSignal,filePath);
            ReadFileThread2 r2 = new ReadFileThread2(doneSignal,filePath2);
            ReadFileThread2 r3 = new ReadFileThread2(doneSignal,filePath3);
            ReadFileThread2 r4 = new ReadFileThread2(doneSignal,filePath4);
            r1.start();
            r2.start();
            r3.start();
            r4.start();
            try {
                doneSignal.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            long endTime = System.currentTimeMillis();
            System.out.println("===============================");
            System.out.println("The totally executed time: "+(endTime-startTime));
        }
    
    }
    
    class ReadFileThread2 extends Thread{
        private RandomAccessFile raf;
        private CountDownLatch doneSignal;
        private final int bufLen = 256;
        private String path;
    
        public ReadFileThread2(CountDownLatch doneSignal,String path){
            this.doneSignal = doneSignal;
            this.path = path;
        }
    
    
        @Override
        public void run() {
            long start = System.currentTimeMillis();
            try {
                raf = new RandomAccessFile(path,"rw");
                raf.seek(0);
                long contentLen = new File(path).length();
                long times = contentLen / bufLen +1;
                byte []buff = new byte[bufLen];
                int hasRead = 0;
                String result = null;
                for(int i=0;i<times;i++){
                    hasRead = raf.read(buff);
                    if(hasRead < 0){
                        break;
                    }
                    result = new String(buff,"gb2312");
                }
                doneSignal.countDown();
            } catch (IOException e) {
                e.printStackTrace();
            }
            long end = System.currentTimeMillis();
            System.out.println(getName() + " " + path +" total Time: " + (end - start));
        }
    }
    

    程序部分说明:
    分别创建4个线程,读取四个不同大小的文件。
    分别计算读取每个文件的时间,然后得到读取4个文件的总时间。

    java.util.concurrent.CountDownLatch 
    一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。
    
    await()使当前线程在锁存器倒计数至零之前一直等待,除非线程被中断。
    
    countDown()递减锁存器的计数,如果计数到达零,则释放所有等待的线程。
    
    线程执行完读取文件的操作,然后锁存器减一,当4个线程都执行读取文件的操作后,锁存器计数为0,执行await方法后,输出总的读取时间。
    加入CountDownLatch 是为了让子线程分别读取完文件后,主线程才能把总的读取时间输出。否则会造成主线程一早就计算时间。
    

    运行结果:

    Thread-8 C:\Users\IBM_ADMIN\Downloads\carootcert(1).der total Time: 8
    Thread-5 C:\Users\IBM_ADMIN\Downloads\马达加斯加3全篇英文台词.txt total Time: 28
    Thread-6 C:\Users\IBM_ADMIN\Downloads\马达加斯加3全篇英文台词2.txt total Time: 4051
    Thread-7 C:\Users\IBM_ADMIN\Downloads\马达加斯加3全篇英文台词3.txt total Time: 5190
    ===============================
    The totally executed time: 5194

    从结果可以看出,总的运行时间接近那个读取最大文件所用的时间。

    ===================================

    不用线程读取多个文件

    package thread;
    
    import java.io.File;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    
    public class ReadMultiFilesWithoutThread {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            long startTime = System.currentTimeMillis();
    
            ReadMultiFilesWithoutThread read = new ReadMultiFilesWithoutThread();
    
            final String filePath3 = "C:\\Users\\IBM_ADMIN\\Downloads\\马达加斯加3全篇英文台词3.txt"; //266M
            final String filePath2 = "C:\\Users\\IBM_ADMIN\\Downloads\\马达加斯加3全篇英文台词2.txt"; //186M
            final String filePath = "C:\\Users\\IBM_ADMIN\\Downloads\\马达加斯加3全篇英文台词.txt"; //39KB
            final String filePath4 = "C:\\Users\\IBM_ADMIN\\Downloads\\carootcert(1).der"; //1KB
    
            read.readFile(filePath);
            read.readFile(filePath2);
            read.readFile(filePath3);
            read.readFile(filePath4);
    
            long endTime = System.currentTimeMillis();
            System.out.println("===============================");
            System.out.println("The totally executed time: "+(endTime-startTime));
        }
    
        public void readFile(String path){
            long start = System.currentTimeMillis();
            int bufLen = 256;
            try {
                RandomAccessFile raf = new RandomAccessFile(path,"rw");
                raf.seek(0);
                long contentLen = new File(path).length();
                long times = contentLen / bufLen +1;
                byte []buff = new byte[bufLen];
                int hasRead = 0;
                String result = null;
                for(int i=0;i<times;i++){
                    hasRead = raf.read(buff);
                    if(hasRead < 0){
                        break;
                    }
                    result = new String(buff,"gb2312");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            long end = System.currentTimeMillis();
            System.out.println( path +" total Time: " + (end - start));
        }
    }
    
    

    程序部分说明:
    分别读取4个大小不同的文件,计算读取每个文件所需的时间。
    计算总共的时间。

    运行结果:

    :\Users\IBM_ADMIN\Downloads\马达加斯加3全篇英文台词.txt total Time: 17
    C:\Users\IBM_ADMIN\Downloads\马达加斯加3全篇英文台词2.txt total Time: 2983
    C:\Users\IBM_ADMIN\Downloads\马达加斯加3全篇英文台词3.txt total Time: 3794
    C:\Users\IBM_ADMIN\Downloads\carootcert(1).der total Time: 1
    ===============================
    The totally executed time: 6795
    

    从结果可以看出,总的运行时间接近所有读取所有文件的时间总和。

    展开全文
  • 参考: https://blog.csdn.net/qq_25473933/article/details/79603253 https://blog.csdn.net/icy_1992/article/details/41869365
  • 易语言多线程读取大文本文件源码,多线程读取大文本文件,线程读取,WideCharToMultiByte
  • Java 多线程读取一个文件

    千次阅读 2017-11-28 18:58:07
     import java.io.IOException; import java.io.RandomAccessFile; import java.util.concurrent.CountDownLatch; /** * 这个线程用来读取文件,当获取到指定关键字时,在指定的对象加1 * @author
  • 前几天,朋友托我帮个忙,问我能不能用多线程的方式,读取一个文件,获取里面的内容。...所以,他就问我要怎么多线程读取一个文件里面的内容,形成多生产者-多消费者的模型,从而提高速度。  因此
  • java多线程同时读取一个文件

    千次阅读 2011-06-02 23:08:00
    转自:... class DownThread extends Thread { //定义字节数组(取水的竹筒)的长度 private final int BUFF_LEN = 32; //定义读取的起始点 ... //定义读取的结束点
  • java多线程读有序地读取一个文件

    千次阅读 2019-05-16 14:13:44
    本人刚参加工作,面试的时候遇四道笔试题,其中就有这道多线程有序读取文件的题目,初看时拿不准,感觉会,有感觉不会。于是放弃了这道题,今天闲下来好好做一遍。 //定义一个runnable接口的实现类 import java.io....
  • java多线程读取个文件 导入数据库

    万次阅读 2016-10-14 16:59:21
    近期在做java读文件的项目,由于数据量较大,因此研究了一下多线程,总结了一下:一. 多个线程读文件和单个线程读文件,效率差不多,甚至可能不如单线程,原因如下:如果只是单纯的读文件一个线程足够了,因为一般...
  • The totally executed time: 2374
  • 主要为大家详细介绍了java使用多线程读取超大文件,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • java多线程批量读取文件()

    万次阅读 2017-04-25 10:22:03
    新公司入职一个多月了,至今没有事情可以做,十来个新同事都一样抓狂...而今天,我所要说的是java多线程读取文件的两个例子; 例子1:java多线程批量读取文件 package face.thread.ReadFile; /**  * 多线程读、写文件
  • 单线程与多线程读取文件

    千次阅读 2017-09-06 15:05:35
    //实验多个线程读取多个文件和单个线程读取多个文件//当文件数量是2-3时,单线程比多线程更快,可能是没有创建线程之类的开销//文件数量增加到10多个以后,多个线程稍微快一点,但是并没有快多少//按照网上的说法...
  • java多线程分区读取文件

    千次阅读 2017-08-09 18:14:46
     为了充分利用多线程读取,就需要把文件划分成多个区域,供每个线程读取。那么就需要有一个算法来计算出每个线程读取的开始位置和结束位置。那么首先根据配置的线程数和文件的总长度计,算出每个线程平均分配的读取...
  • 文件上传-队列多线程读取文件内容

    千次阅读 2016-08-22 18:25:59
    队列多线程读取文件内容 为什么采用多线程队列的方式呢?主要是如果文件一行读取处理的话,页面上传文件后,需要等待服务器响应。如果文件的内容数据量很大的话,页面就一直等待服务器响应,毕竟服务器处理这些...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 431,164
精华内容 172,465
关键字:

多线程按行读取一个文件