单线程读取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 之前就会先把多线程执行完，就可以的到结果。
分享到：
相关推荐
Java多线程读大文件 java多线程写文件：多线程往队列中写入数据
Qt Creator 多线程读取文件到程序显示 利用QT Creator多任务读取一个文档到程序里 为了防止直接读取文件里的内容太大而发生卡顿，于是多线程读取将更高效的解决这个问题。 效果图如下： 其中pro文件无需改动，...
在“易语言多线程读取大文本文件”这个主题中，核心概念是多线程和文件I/O操作。多线程允许程序同时执行多个独立的任务，提高效率，尤其在处理大型文件时，可以将任务分割成多个部分，由不同的线程并行处理。这可以...
简单的利用互斥变量、原子操作等技术实现多线程读写文件时的互斥，从而确保文件在操作过程中不会被破坏。例子并没有使用很多复杂的逻辑。适合刚接触多线程编程的新手学习理解多线程程序的编程思路。
本源码示例是关于如何在易语言中实现多线程读取大文本文件，这对于处理大量数据或长时间运行的任务尤其有用。以下将详细介绍这一技术及其应用。 首先，理解多线程的概念至关重要。在单线程环境中，程序按照顺序执行...
然后，在`file_lock.py`的2.1部分，展示了没有使用任何同步机制（即不加锁）的多线程读写文件。这会导致并发问题，如输出所示，数据被错误地读取和写入，因为多个线程可能同时访问文件，导致数据混乱。 为了修复这...
为了在多线程环境下安全地读写文件，我们需要考虑线程同步问题。可以通过使用CSingleLock或CCriticalSection等同步对象来确保在任何时候只有一个线程能访问文件，防止数据冲突。 此外，调试时，可以借助串口调试...
特别是在处理大量数据时，如读写文件，多线程可以同时执行不同的任务，从而显著提高整体性能。本项目着重探讨如何在多线程环境中实现安全有效的文件读写操作。 首先，我们需要理解多线程的基本概念。在单核处理器...
Java多线程读写文件示例 Java多线程读写文件示例是指在Java编程语言中使用多线程技术来实现文件的读写操作。该示例主要介绍了如何使用Java多线程技术来实现文件的读写操作，包括文件的写入、读取和同步控制等。 ...
3.读取的文件使用多线程处理，不影响显示界面正常操作； 4.读取过来的文件如有修改，需要保存修改部分； 5.读、写文件需要显示处理进度； 6.增加一个列表，用于展示文本文件的类型、大小、行数等。 一、功能列表 1....
在Java编程中，多线程技术是提升程序执行效率的关键之一，特别是在进行文件读写操作时。本主题将深入探讨如何使用多线程来优化文件的读取和写入过程，以及需要注意的相关问题。 首先，我们需要理解单线程与多线程在...
本文将详细探讨多线程读取大文件的原理、实现方法以及其在实际应用中的优势。 首先，理解“多线程”这一概念是至关重要的。线程是操作系统分配CPU资源的基本单位，一个进程可以包含多个线程。在单线程环境下，程序...
Java多线程读取大文本文件并批量插入MongoDB的代码，文本文件,csv文件，可以结合POI改造使其支持excel。 适合做大量文本数据或日志文件入库的场景，大文本被拆分成多个线程处理，速度快。 批量插入MongoDB，存在则...
在Java编程中，多线程读取多个文件是一项常见需求，尤其在文件数量较多或者文件较大时，能够提升处理效率。本文将详细介绍如何在Java中使用多线程来同时读取多个文件。 首先，本文涉及到的核心类是`Thread`类，这是...
带进度条可停止的多线程读写文件意味着我们需要一种机制来控制线程的执行和停止。在VC++中，可以通过设置线程的共享变量（如布尔标志）来实现这一目标。当用户请求停止时，主线程会修改这个标志，被创建的线程在检查...
特别是在处理I/O密集型任务（如读写文件）时，多线程可以显著提升性能。在这个“一个多线程同步读写的小程序”中，我们看到开发者尝试通过创建读线程和写线程来同时进行数据的读取和写入，以优化程序的执行流程。 ...
C++实现多线程文件复制 在文件复制过程中，多线程技术可以大大提高复制速度。下面将详细介绍C++实现多线程文件复制的知识点。 一、多线程文件复制的基本概念 多线程文件复制是指在文件复制过程中，使用多个线程...
在IT领域，尤其是在地理信息系统（GIS）开发中，"基于多线程和gdal类库的影像读写"是一个关键的技术点。GDAL（Geospatial Data Abstraction Library）是一个强大的开源库，用于处理多种遥感和地图数据格式，包括TIFF...
Delphi提供了多种文件操作函数，如ReadFile和WriteFile，以及高级的类如TStreamReader和TStreamWriter，它们可以帮助我们方便地读写文件。 4. **数据处理**：线程读取数据后，可以进行必要的处理，例如解析、过滤或...