多线程读取文件
单线程读取10K个 文件的话会显的非常的慢，但是如果我们开启多个线程去读取，会让读取的速度大大的加快，顺便说一下多线程的注意事项：synchronized 代码快中 尽量简短，不要有 类似socket.accept() inputstream.read() 这样的阻塞式的方法，这样会让程序减慢，如果synchronized代码快中的东西太多，容易造成单线程的囧地，而且速度还不如单线程快。
废话少说，我们来看看代码：
1.生成10K个 文件：
多线程 读取
所有的东西 都放到 synchronazied代码快中的速度比较，这个类似单线程
单线程去读的速度：
通过比较，大家就可以发现多线程的好处了，可能大家多如何写多线程存在疑问，这里我想说的是多想想，你的多线程是想做什么，就像 这个 例子，我的多线程 就是想 每个人线程分担 不同的文件读取，再算总和，所以我要控制的同步资源就是文件的名称和总和，所以我就需要把这两个 属性 同步上，这样就可以。如何返回多线程执行完的结果呢，我个人认为这样做，是让其他线程在mian 之前完成，这样就可以达到效果，可以用thread.join()方法，这样在执行mian 之前就会先把多线程执行完，就可以的到结果。
废话少说，我们来看看代码：
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 之前就会先把多线程执行完，就可以的到结果。