㈠ java 怎么用10个线程去读取文件夹里100个txt文件中的内容，读完之后同步写到一个文件中去。
这个是我写的三个类，用于多线程操作读取文件内容和写入文件内容，不知道是不是你合你味口。
________________第一个类______读取内容__写入内容____________________
package pro;
import java.io.*;
public class ReadFileToWriteOtherFile {
private File oldFile;
private File newFile;
private BufferedReader br;
private BufferedWriter bw;
private String totalString="";
private Boolean flag=true; //用于标记文件名是否存在 true表示存在
public ReadFileToWriteOtherFile()
{
oldFile=null;
newFile=null;
br=null;
bw=null;
System.out.println("初始化成功");
}
public void readInfoFromFile(String fileName)
{
System.out.println("开始读取");
try
{
oldFile=new File(fileName);
if(oldFile.exists()) //如果文件存在
{
System.out.println("存在");
br=new BufferedReader(new FileReader(oldFile));
String info=br.readLine(); //读取一行
while(info!=null)
{
totalString+=info; //将读取到的一行添加到totalString中
info=br.readLine(); //再读取下一行
//System.out.println(totalString);
}
System.out.println("读取完成，准备写入…………");
}
else //如果文件不存在
{
System.out.println("文件不存在");
flag=false; //标记该文件不存在
}
// System.out.println("totalString="+totalString);
}
catch(FileNotFoundException e)
{
System.out.println(e);System.out.println("开始读取中1");
}
catch(IOException e)
{System.out.println(e);System.out.println("开始读取中2");}
}
public void writeInfoToFile(String fileName)
{
if(!flag) //如果标记前面的文件不存在，则return
{
flag=true; //改回原来的文件标记符
return;
}
try
{
newFile=new File(fileName);
if(newFile.exists()) //如果存在，不用创建新文件
{
System.out.println("文件存在，可以写入!");
}
else //如果不存在，则创建一个新文件
{
System.out.println("文件不存在，准备创建新文件");
newFile.createNewFile();
System.out.println("文件创建成功，可以写入");
}
bw=new BufferedWriter(new FileWriter(newFile,true));
// System.out.println("totalString="+totalString);
bw.write(totalString,0,totalString.length());
bw.flush(); //刷新缓冲区
System.out.println("写入完成");
totalString="\r\t"; //清空原来的字符串
}
catch(FileNotFoundException e)
{System.out.println(e);}
catch(IOException e)
{System.out.println(e);}
}
}
________________第二个类______一个自定义的线程类____________________
package pro;
import java.lang.Thread;
public class MyThread extends Thread
{
private int index; //用于数组的位置
private String[] fileNames; //定义一个字符串数组
ReadFileToWriteOtherFile bftwo=new ReadFileToWriteOtherFile(); //定义前面的自定义类
public MyThread(String[] fileNames,int index) //index表示数组位置标号
{
this.index=index;
this.fileNames=fileNames;
}
public void run()
{
bftwo.readInfoFromFile(fileNames[index]);//传入数组中的字符串参数
bftwo.writeInfoToFile("b.txt"); //传入写入的目的地文件
//index++; //数组位置加1
System.out.println("==============");//分隔线
}
}
________________第三个类______主程序____________________
package pro;
//import org.springframework.context.ApplicationContext;
//import org.springframework.context.support.;
import java.io.*;
public class BeanRunApp {
/**
* Method main
*
*
* @param args
*
*/
public static void main(String[] args)
{
/* ApplicationContext apc=new ("beans.xml");
ClassRoom croom=(ClassRoom)apc.getBean("classRoom");
croom.out();
System.out.println("over");
*/
long startTime=System.currentTimeMillis();
String[] a={"a.txt","c.txt","d.txt","e.txt"}; //用一个符品数组保存文件名
for(int i=0;i<a.length;i++) //用数组的长度来作为循环条件
{ //把这个数组和i的值作为构造函数传入线程类
MyThread myth=new MyThread(a,i);
System.out.println("--------------------------------");
myth.start(); //执行
System.out.println("当前的线程是:"+myth.getName());
}
long endTime=System.currentTimeMillis();
System.out.println("耗时:"+(endTime-startTime)+"毫秒");
}
}
㈡ “java”中多线程按行读取txt且每个线程读的内容不能重复，这么求“demo”
你把原来程序中直接读的地方，改成调用上面的函数，由该函数统一读行。这样，不管是你有 N 个线程，还是一个线程，都不会发生读的行重复，或者读的行不完整的现象了。
为了充分利用多线程读取，就需要把文件划分成多个区域，供每个线程读取。那么就需要有一个算法来计算出每个线程读取的开始位置和结束位置。那么首先根据配置的线程数和文件的总长度计，算出每个线程平均分配的读取长度。
但是有一点，由于文件是纯文本文件，必须按行来处理，如果分割点在某一行中间，那么这一行数据就会被分成两部分，分别由两个线程同时处理，这种情况是不能出现的。所以各个区域的结束点上的字符必须是换行符。第一个区域的开始位置是0，结束位置首先设为（文件长度/线程数），如果结束点位置不是换行符，就只能加1，直到是换行符位置。
㈢ java多线程同时读取一个文件，这个方法可行吗
不可行。每次读取文件都需要创建缓存文件流，很占内存，而且多次读取实际上也是一个文件，还不如直接读取文件，之后通过条件多次获取需要的内容来的实际。
可以通过BufferedReader
流的形式进行流缓存，之后通过readLine方法获取到缓存的内容。
BufferedReader
bre
=
null;
try
{
String
file
=
"D:/test/test.txt";
bre
=
new
BufferedReader(new
FileReader(file));//此时获取到的bre就是整个文件的缓存流
while
((str
=
bre.readLine())!=
null)
//
判断最后一行不存在，为空结束循环
{
System.out.println(str);//原样输出读到的内容，此处可以添加条件进行不同的处理
}；
备注：
流用完之后必须close掉，如上面的就应该是：bre.close()，否则bre流会一直存在，直到程序运行结束。
㈣ java 多线程读取txt 文件
多线程将读取的数据全部读取到一个Buffer里面去，然后再通过Buffer去处理，也就是生产者消费者模型，你将txt读取到一个ByteBuffer或者是大字节数组队列里面都可以，然后通过其它处理线程进行按行分隔
㈤ Java如何使用多线程读取40M的文件
1，读取文件大小（比如大小是200K）。
2，启动5个线程，第一个线程从其实读，第二个线程跳过40在读40。。
㈥ 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多线程如何实现特定线程读取磁盘上特定标识的文件
classWorkerimplementsRunnable{
privateStringfilename;
publicWorker(Stringfilename){
this.filename=filename;
}
@Override
publicvoidrun(){
FileReaderfr=newFileReader(filename);
fr.read();//读一个字符
...//以及其他操作
fr.close();
}
}
publicclassFoobar{
publicstaticvoidmain(String[]args){
Workerw1=newWorker("a.txt");
Workerw2=newWorker("b.txt");
Workerw3=newWorker("c.txt")
Threadt1=newThread(w1);
Threadt2=newThread(w2);
Threadt3=newThread(w3);
t1.start();
t2.start();
t3.start();
}
}
㈧ 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:/勇敢的心.rmvb";
InputStream[] isArr = new InputStream[DOWN_THREAD_NUM];
RandomAccessFile[] outArr = new RandomAccessFile[DOWN_THREAD_NUM];
try {
isArr[0] = new FileInputStream("d:/勇敢的心.rmvb");
long fileLen = getFileLength(new File("d:/勇敢的心.rmvb"));
System.out.println("文件的大小" + fileLen);
//以输出文件名创建第一个RandomAccessFile输出流
outArr[0] = new RandomAccessFile(OUT_FILE_NAME, "rw");
//创建一个与文件相同大小的空文件
for (int i = 0; i < fileLen; i++) {
outArr[0].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线程读取吗
可以。但是由于机械磁盘只能同时一个线程访问，所以多线程的读取效率可能还不如单线程。
㈩ java中怎么用多个线程同时对一个文件读取，最终将文件内容保存到一个字节数组中去呢
多线程读取文件在一块硬盘上没用，瓶颈在硬盘I/O，而不在CPU和内存。读取文件时，CPU不用复杂的计算工作，只是数据传输而已，多线程反而造成磁头来回移动，效率不高。如果是两块以上的硬盘，可以用不同的线程访问不同的硬盘，效率比单线程要高
而且多线程操作同一文件除了效率还会有多线程问题，多个线程同时往数组里存数据还会有线程安全问题，如果不同步处理读取的文件就是错误的。
如果读取的话只能设置每个线程各自读取偏 移量
读取文件大小（比如大小是200K）。 2，启动5个线程，第一个线程读到40，第二个线程跳过40在读到80，总之得合理安排好各个线程读取的大小。这样才能不重复读取。大数据处理框架maprece原理和此类似