`
kaobian
  • 浏览: 211637 次
  • 性别: Icon_minigender_1
  • 来自: 哈尔滨
社区版块
存档分类
最新评论

多线程读取文件

Java多线程文件读取 
阅读更多
单线程读取10K个 文件的话会显的非常的慢，但是如果我们开启多个线程去读取，会让读取的速度大大的加快，顺便说一下多线程的注意事项：synchronized 代码快中 尽量简短，不要有 类似socket.accept() inputstream.read() 这样的阻塞式的方法，这样会让程序减慢，如果synchronized代码快中的东西太多，容易造成单线程的囧地，而且速度还不如单线程快。

废话少说，我们来看看代码：
1.生成10K个 文件： 
package com.fileThread;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class GenFile {

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {

        File file = null;
        OutputStream out = null;

        file = new File("c:/file");
        if(!file.exists()){
            file.mkdirs();
        }
        for (int i = 0; i < 10000; i++) {
            file = new File("c:/file/file" + i + ".txt");
            out = new FileOutputStream(file);
            out.write("nihao1hh1hh1".getBytes());
            out.close();
        }
        file = null;
        out = null;
    }

}

多线程 读取 
package com.fileThread;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class ReadFile {

    public static void main(String[] args) throws Exception {
        Sum sum = new Sum();
        Thread t1 = new Thread(sum);
        Thread t2 = new Thread(sum);
        Thread t3 = new Thread(sum);
        t1.start();
        t2.start();
        t3.start();
        // t1.run();
        // t2.run();
        // t3.run();
        // System.out.println(sum.getSum()+"==");
    }
}

class Sum implements Runnable {
    private Integer i = 0;
    private Integer sum = 0;
    static long time;

    public void run() {
        File file = null;
        InputStream is = null;
        StringBuffer sb = null;
        while (true) {
            if (i == 0) {
                time = System.currentTimeMillis();
            }
            if (i == 10000) {
                break;
            }
            synchronized (this) {
                file = new File("c:/file/file" + i + ".txt");
                // System.out.println(i + "currentThread==" +
                // Thread.currentThread().getName()); 

              i++;


            }
           
            try {
                is = new FileInputStream(file);
            } catch (FileNotFoundException e) {
            }
            byte[] data = new byte[2048];
            int len = 0;
            sb = new StringBuffer();
            try {
                while ((len = is.read(data)) != -1) {
                    sb.append(new String(data, 0, len));
                }
            } catch (IOException e) {
            }
            String result = sb.toString();
            String[] arr = result.split("\\D+");
            synchronized (this) {
                for (String s : arr) {
                    if (s != null && s.trim().length() > 0) {
                        sum += Integer.parseInt(s);
                    }
                }
            }
        }
        file = null;
        sb = null;
        is = null;
        System.out.println(this.sum);
        System.out.println(System.currentTimeMillis() - time);
    }

    public Integer getI() {
        return i;
    }

    public void setI(Integer i) {
        this.i = i;
    }

    public Integer getSum() {
        return sum;
    }

    public void setSum(Integer sum) {
        this.sum = sum;
    }

}

所有的东西 都放到 synchronazied代码快中的速度比较，这个类似单线程 

package com.fileThread;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class ReadFileAll {

    public static void main(String[] args) throws Exception {
        Sums sum = new Sums();
        Thread t1 = new Thread(sum);
        Thread t2 = new Thread(sum);
        Thread t3 = new Thread(sum);
        t1.start();
        t2.start();
        t3.start();
        // 22562
        // 14625
    }
}

class Sums implements Runnable {
    private Integer i = 0;
    private Integer sum = 0;
    static long time;

    public void run() {
        File file = null;
        InputStream is = null;
        StringBuffer sb = null;
        while (true) {
            if (i == 0) {
                time = System.currentTimeMillis();
            }
            if (i == 10000) {
                break;
            }
            synchronized (this) {
                file = new File("c:/file/file" + i + ".txt");
//                System.out.println(i + "currentThread=="
//                        + Thread.currentThread().getName());
                i++;
                try {
                    is = new FileInputStream(file);
                } catch (FileNotFoundException e) {
                }
                byte[] data = new byte[2048];
                int len = 0;
                sb = new StringBuffer();
                try {
                    while ((len = is.read(data)) != -1) {
                        sb.append(new String(data, 0, len));
                    }
                } catch (IOException e) {
                }
                String result = sb.toString();
                String[] arr = result.split("\\D+");
                for (String s : arr) {
                    if (s != null && s.trim().length() > 0) {
                        sum += Integer.parseInt(s);
                    }
                }
            }
        }
        file = null;
        sb = null;
        is = null;
        System.out.println(this.sum);
        System.out.println(System.currentTimeMillis() - time);
    }

    public Integer getI() {
        return i;
    }

    public void setI(Integer i) {
        this.i = i;
    }

    public Integer getSum() {
        return sum;
    }

    public void setSum(Integer sum) {
        this.sum = sum;
    }

}

单线程去读的速度： 

package com.fileThread;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class ReadFileSingleThread {

    public static void main(String[] args) throws Exception {
        int i = 0;
        long time = 0;
        int sum =0;
        File file = null;
        InputStream is = null;
        StringBuffer sb = null;
        while (true) {
            if (i == 0) {
                time = System.currentTimeMillis();
            }
            if (i == 10000) {
                break;
            }
            file = new File("c:/file/file" + i + ".txt");
            i++;
            try {
                is = new FileInputStream(file);
            } catch (FileNotFoundException e) {
            }
            byte[] data = new byte[2048];
            int len = 0;
            sb = new StringBuffer();
            try {
                while ((len = is.read(data)) != -1) {
                    sb.append(new String(data, 0, len));
                }
            } catch (IOException e) {
            }
            String result = sb.toString();
            String[] arr = result.split("\\D+");
            for (String s : arr) {
                if (s != null && s.trim().length() > 0) {
                    sum += Integer.parseInt(s);
                }
            }
        }
        file = null;
        sb = null;
        is = null;
        System.out.println(sum);
        System.out.println(System.currentTimeMillis() - time);
    }
}



通过比较，大家就可以发现多线程的好处了，可能大家多如何写多线程存在疑问，这里我想说的是多想想，你的多线程是想做什么，就像 这个 例子，我的多线程 就是想 每个人线程分担 不同的文件读取，再算总和，所以我要控制的同步资源就是文件的名称和总和，所以我就需要把这两个 属性 同步上，这样就可以。如何返回多线程执行完的结果呢，我个人认为这样做，是让其他线程在mian 之前完成，这样就可以达到效果，可以用thread.join()方法，这样在执行mian 之前就会先把多线程执行完，就可以的到结果。
4
顶
7
踩
分享到：
| 模拟tomcat工作原理
评论
10 楼 bq_test1 2015-01-20  
我是这么理解的，你的synchorized方法还没执行完，i已经变成了10000，此时外面的线程在  if (i == 10000) { 
                break; 
            }  这句话下面等待执行，把10000跳过去了，然后后面的也不会中断了。
但是第一个类ReadFile 却可以正常结束执行，很诡异。建议把while里的有关i的数据操作都放到synchorized里面。
9 楼 bq_test1 2015-01-20  
ReadFileAll 这个类的run方法多线程执行会阻塞，没有跳出while循环，楼主测一下。
8 楼 bq_test1 2015-01-20  
你好，我想请教个问题。
单线程读取大文件和多线程读取大文件是否会对内存的使用有什么不同？比如单线程更容易造成内存溢出，而多线程不容易？
7 楼 lynnkong 2011-07-18  
i++;

这个可以用AtomicInteger类的addAndGet代替。
6 楼 kaobian 2011-07-18  
Dark-Mraz 写道
kaobian 写道
Dark-Mraz 写道
仔细看了看，楼主的每个Runnable对象拥有独立的计数器，并非共享。那多线程的用意何在？

这个你说错了，这三个是共享同一个计数器的，你可以跑一下程序看看


看错了，以为你扔了三个不同的Runnable对象给3个线程。原来是同一个

呵呵，很感谢你的评语，谢谢你的关注 
5 楼 Dark-Mraz 2011-07-18  
kaobian 写道
Dark-Mraz 写道
仔细看了看，楼主的每个Runnable对象拥有独立的计数器，并非共享。那多线程的用意何在？

这个你说错了，这三个是共享同一个计数器的，你可以跑一下程序看看


看错了，以为你扔了三个不同的Runnable对象给3个线程。原来是同一个
4 楼 kaobian 2011-07-18  
Dark-Mraz 写道
仔细看了看，楼主的每个Runnable对象拥有独立的计数器，并非共享。那多线程的用意何在？

这个你说错了，这三个是共享同一个计数器的，你可以跑一下程序看看
3 楼 kaobian 2011-07-18  
Dark-Mraz 写道
多线程读有些问题

 synchronized (this) {
                file = new File("c:/file/file" + i + ".txt");
                // System.out.println(i + "currentThread==" +
                // Thread.currentThread().getName());
            }
            i++;


i++在同步块之外，无法保证计数器的线程安全。

假设当前线程释放锁，即将执行i++但还未执行时，其他线程获得对象锁执行了new File
则导致文件被重复读取，且下一个文件被跳过未被读取。

呵呵你说的对，这个是应该放到同步代码块中的。
2 楼 Dark-Mraz 2011-07-18  
仔细看了看，楼主的每个Runnable对象拥有独立的计数器，并非共享。那多线程的用意何在？
1 楼 Dark-Mraz 2011-07-18  
多线程读有些问题

 synchronized (this) {
                file = new File("c:/file/file" + i + ".txt");
                // System.out.println(i + "currentThread==" +
                // Thread.currentThread().getName());
            }
            i++;


i++在同步块之外，无法保证计数器的线程安全。

假设当前线程释放锁，即将执行i++但还未执行时，其他线程获得对象锁执行了new File
则导致文件被重复读取，且下一个文件被跳过未被读取。
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java多线程读取文件

    Java多线程读大文件 java多线程写文件：多线程往队列中写入数据

    QT多线程技术读取文档内容到程序里

    Qt Creator 多线程读取文件到程序显示 利用QT Creator多任务读取一个文档到程序里 为了防止直接读取文件里的内容太大而发生卡顿，于是多线程读取将更高效的解决这个问题。 效果图如下： 其中pro文件无需改动，...

    易语言多线程读取大文本文件

    在“易语言多线程读取大文本文件”这个主题中，核心概念是多线程和文件I/O操作。多线程允许程序同时执行多个独立的任务，提高效率，尤其在处理大型文件时，可以将任务分割成多个部分，由不同的线程并行处理。这可以...

    VC++ 多线程文件读写操作实例

    简单的利用互斥变量、原子操作等技术实现多线程读写文件时的互斥，从而确保文件在操作过程中不会被破坏。例子并没有使用很多复杂的逻辑。适合刚接触多线程编程的新手学习理解多线程程序的编程思路。

    易语言多线程读取大文本文件源码

    本源码示例是关于如何在易语言中实现多线程读取大文本文件，这对于处理大量数据或长时间运行的任务尤其有用。以下将详细介绍这一技术及其应用。 首先，理解多线程的概念至关重要。在单线程环境中，程序按照顺序执行...

    python多线程同步之文件读写控制

    然后，在`file_lock.py`的2.1部分，展示了没有使用任何同步机制（即不加锁）的多线程读写文件。这会导致并发问题，如输出所示，数据被错误地读取和写入，因为多个线程可能同时访问文件，导致数据混乱。 为了修复这...

    用多线程实现串口读写数据以及文件的读写

    为了在多线程环境下安全地读写文件，我们需要考虑线程同步问题。可以通过使用CSingleLock或CCriticalSection等同步对象来确保在任何时候只有一个线程能访问文件，防止数据冲突。 此外，调试时，可以借助串口调试...

    多线程通信读写文件

    特别是在处理大量数据时，如读写文件，多线程可以同时执行不同的任务，从而显著提高整体性能。本项目着重探讨如何在多线程环境中实现安全有效的文件读写操作。 首先，我们需要理解多线程的基本概念。在单核处理器...

    java多线程读写文件示例

    Java多线程读写文件示例 Java多线程读写文件示例是指在Java编程语言中使用多线程技术来实现文件的读写操作。该示例主要介绍了如何使用Java多线程技术来实现文件的读写操作，包括文件的写入、读取和同步控制等。 ...

    Qt多线程读写大型文本文件项目

    3.读取的文件使用多线程处理，不影响显示界面正常操作； 4.读取过来的文件如有修改，需要保存修改部分； 5.读、写文件需要显示处理进度； 6.增加一个列表，用于展示文本文件的类型、大小、行数等。 一、功能列表 1....

    多线程对文件读写操作(java)

    在Java编程中，多线程技术是提升程序执行效率的关键之一，特别是在进行文件读写操作时。本主题将深入探讨如何使用多线程来优化文件的读取和写入过程，以及需要注意的相关问题。 首先，我们需要理解单线程与多线程在...

    多线程读取大文件

    本文将详细探讨多线程读取大文件的原理、实现方法以及其在实际应用中的优势。 首先，理解“多线程”这一概念是至关重要的。线程是操作系统分配CPU资源的基本单位，一个进程可以包含多个线程。在单线程环境下，程序...

    Java多线程读取大文本文件并批量插入MongoDB的实战代码

    Java多线程读取大文本文件并批量插入MongoDB的代码，文本文件,csv文件，可以结合POI改造使其支持excel。 适合做大量文本数据或日志文件入库的场景，大文本被拆分成多个线程处理，速度快。 批量插入MongoDB，存在则...

    java多线程读取多个文件的方法

    在Java编程中，多线程读取多个文件是一项常见需求，尤其在文件数量较多或者文件较大时，能够提升处理效率。本文将详细介绍如何在Java中使用多线程来同时读取多个文件。 首先，本文涉及到的核心类是`Thread`类，这是...

    有进度条多线程的写入文件

    带进度条可停止的多线程读写文件意味着我们需要一种机制来控制线程的执行和停止。在VC++中，可以通过设置线程的共享变量（如布尔标志）来实现这一目标。当用户请求停止时，主线程会修改这个标志，被创建的线程在检查...

    一个多线程同步读写的小程序

    特别是在处理I/O密集型任务（如读写文件）时，多线程可以显著提升性能。在这个“一个多线程同步读写的小程序”中，我们看到开发者尝试通过创建读线程和写线程来同时进行数据的读取和写入，以优化程序的执行流程。 ...

    C++实现多线程文件复制.docx

    C++实现多线程文件复制 在文件复制过程中，多线程技术可以大大提高复制速度。下面将详细介绍C++实现多线程文件复制的知识点。 一、多线程文件复制的基本概念 多线程文件复制是指在文件复制过程中，使用多个线程...

    多线程全面遍历磁盘文件

    在遍历磁盘文件时，如果使用多线程，我们可以将磁盘的不同区域分配给不同的线程，这样就能并行地读取和处理文件，从而显著提高遍历速度。 实现多线程遍历磁盘文件，我们需要以下几个关键步骤： 1. **创建线程池**...

    SpringBoot版本的多线程下载文件，分段下载文件

    本篇将深入探讨如何利用SpringBoot实现多线程下载文件以及分段下载文件的技术。 首先，多线程下载文件是一种提高下载速度的方法，通过将大文件分成多个小部分，每个部分由一个单独的线程负责下载，从而充分利用多核...

Magicbox
Global site tag (gtag.js) - Google Analytics