java多线程读取同一个文件（java中怎么用多个线程同时对一个文件读取，最终将文件内容保存到一个字节数组中去呢）

本文目录

• java中怎么用多个线程同时对一个文件读取，最终将文件内容保存到一个字节数组中去呢
• JAVA中如何用线程读取一个文件里的数据!
• java多线程读写文件
• Java编程多个线程如何访问同一个共享资源
• java读写同一个文件
• java中不同的线程可以同时操作一个文件吗

java中怎么用多个线程同时对一个文件读取，最终将文件内容保存到一个字节数组中去呢

多线程读取文件在一块硬盘上没用，瓶颈在硬盘I/O，而不在CPU和内存。读取文件时，CPU不用复杂的计算工作，只是数据传输而已，多线程反而造成磁头来回移动，效率不高。如果是两块以上的硬盘，可以用不同的线程访问不同的硬盘，效率比单线程要高
而且多线程操作同一文件除了效率还会有多线程问题，多个线程同时往数组里存数据还会有线程安全问题，如果不同步处理读取的文件就是错误的。
如果读取的话只能设置每个线程各自读取偏 移量
读取文件大小（比如大小是200K）。 2，启动5个线程，第一个线程读到40，第二个线程跳过40在读到80，总之得合理安排好各个线程读取的大小。这样才能不重复读取。大数据处理框架mapreduce原理和此类似

JAVA中如何用线程读取一个文件里的数据!

import java.io.*;
class DownThread extends Thread {
//定义字节数组（取水的竹筒）的长度
private final int BUFF_LEN = 32;
//定义读取的起始点
private long start;
//定义读取的结束点
private long end;
//读取文件对应的输入流
private InputStream is;
//将读取到的字节输出到raf中
private RandomAccessFile raf;

//构造器，传入输入流，输出流和读取起始点、结束点
public DownThread(long start, long end, InputStream is, RandomAccessFile raf) {
//输出该线程负责读取的字节位置
System.out.println(start + “----》“ + end);
this.start = start;
this.end = end;
this.is = is;
this.raf = raf;
}

public void run() {
try {
is.skip(start);
raf.seek(start);
//定义读取输入流内容的的缓存数组（竹筒）
byte buff = new byte[BUFF_LEN];
//本线程负责读取文件的大小
long contentLen = end - start;
//定义最多需要读取几次就可以完成本线程的读取
long times = contentLen / BUFF_LEN + 4;
//实际读取的字节数
int hasRead = 0;
for (int i = 0; i 《 times; i++) {
hasRead = is.read(buff);
//如果读取的字节数小于0，则退出循环！
if (hasRead 《 0) {
break;
}
raf.write(buff, 0, hasRead);
}
} catch (Exception ex) {
ex.printStackTrace();
}
//使用finally块来关闭当前线程的输入流、输出流
finally {
try {
if (is != null) {
is.close();
}
if (raf != null) {
raf.close();
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
}

public class MutilDown {
public static void main(String args) {
final int DOWN_THREAD_NUM = 4;
final String OUT_FILE_NAME = “d:/copy勇敢的心.rmvb“;
InputStream isArr = new InputStream[DOWN_THREAD_NUM];
RandomAccessFile outArr = new RandomAccessFile[DOWN_THREAD_NUM];
try {

isArr = new FileInputStream(“d:/勇敢的心.rmvb“);
long fileLen = getFileLength(new File(“d:/勇敢的心.rmvb“));
System.out.println(“文件的大小“ + fileLen);
//以输出文件名创建第一个RandomAccessFile输出流
outArr = new RandomAccessFile(OUT_FILE_NAME, “rw“);
//创建一个与文件相同大小的空文件
for (int i = 0; i 《 fileLen; i++) {
outArr.write(0);
}
//每线程应该读取的字节数
long numPerThred = fileLen / DOWN_THREAD_NUM;
//整个文件整除后剩下的余数
long left = fileLen % DOWN_THREAD_NUM;
for (int i = 0; i 《 DOWN_THREAD_NUM; i++) {
//为每个线程打开一个输入流、一个RandomAccessFile对象，
//让每个线程分别负责读取文件的不同部分。
if (i != 0) {

isArr[i] = new FileInputStream(“d:/勇敢的心.rmvb“);
//以指定输出文件创建多个RandomAccessFile对象
outArr[i] = new RandomAccessFile(OUT_FILE_NAME, “rw“);
}
if (i == DOWN_THREAD_NUM - 1) {
//最后一个线程读取指定numPerThred+left个字节
new DownThread(i * numPerThred, (i + 1) * numPerThred
+ left, isArr[i], outArr[i]).start();
} else {
//每个线程负责读取一定的numPerThred个字节
new DownThread(i * numPerThred, (i + 1) * numPerThred,
isArr[i], outArr[i]).start();
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
}

public static long getFileLength(File file) {
long length = 0;
//获取文件的长度
long size = file.length();
length = size;
return length;
}
}

java多线程读写文件

public static void main(String args) {
File data = new File(“data.txt“);
try {
InputStreamReader read = new InputStreamReader(new FileInputStream(
data), “UTF-8“);
final BufferedReader bufferedReader = new BufferedReader(read);
for (int i = 0; i 《 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
String lineTXT = null;
synchronized (bufferedReader) {
try {
while ((lineTXT = bufferedReader.readLine()) != null) {
System.out.println(Thread.currentThread()+“:“+lineTXT);
bufferedReader.notify();
bufferedReader.wait();
}
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
bufferedReader.notifyAll();
}
}
}
}).start();
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}

Java编程多个线程如何访问同一个共享资源

如果该方法不涉及写公共的资源比如一个静态的变量或者写文件，修改某个数据库的值的时候没有影响
比如你这个类里的方法只是对输入的参数做一个计算然后返回计算的值就没有影响。
但是如果是修改公共的资源比如修改数据库中存储的一个value则有可能出现问题，如：

public void writeDb(String key, String value) {
collectiondb();
write(key, value);
closeDbCollection();
}

因为Java的线程运行顺序是不一定的，可以第一个线程运行完连接数据库到后挂起了，这时候第二个线程开始运行，如果你的collectiondb()处理使用的是类中的一个实例变量Connection conn来保存数据库的连接，当第二个线程运行完毕以后conn也被关闭了，第一个线程继续执行write函数写数据库值的时候就会抛出异常。
这是一个例子，还有其他可能产生脏数据的问题
多线程如果使用公共资源的话最好在方法上声明synchronized关键字让其同步

java读写同一个文件

读取文件有三种方式，r, w, a，读，覆盖写， 追加写， new FileReader(file)以读的方式打开了文件，两个马上就以new FileWriter(file)方式覆盖写文件，文件自然是空白的，之后你readLine读到的是null,即String line是null,然后你要writer.write(line); 即writer.write(null); 自然报空指针；
建议，如果边读边写，考虑RandomAccessFile类

java中不同的线程可以同时操作一个文件吗

   Java中不同的线程是可以同时操作一个文件的，只不过有时候因为进程执行的快慢，会出现数据读取不同步的问题，例子如下：