java多线程文件

Ⅰ 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大数据 多线程写文件

1、采用public static的变量存储这一数值，每个线程都往这一共有静态变量里写入已复制大小。 2、采用Callable方式实现多线程，将结果作为返回值返回到主线程。这一方法只能在所有子线程都完成之后才能通过future获取。

Ⅲ 要用java实现多线程的文件上传该如何去做

的资源消耗，因此，在进行同类事情，需要进行互相的通讯等等事情的时候，都采用线程来进行处理。

对于只做固定的一件事情（比如：计算1+2+3+...+9999999）来说，其性能上不会比采用单线程的整体效率高，原因是，同时都是要做这么多运算，采用多线程的话，系统在进行线程调度的过程中喙浪费一些资源和时间，从而性能上下降。

那么，多线程是否就没有存在的意义了呢？答案当然不是的。多线程还是有存在的价值的，我们在写输入流输出流，写网络程序等等的时候，都会出现阻塞的情况，如果说，我们不使用多线程的话，从A中读数据出来的时候，A因为没有准备好，而整个程序阻塞了，其他的任何事情都没法进行。如果采用多线程的话，你就不用担心这个问题了。还举个例子：游戏中，如果A角色和B角色采用同一个线程来处理的话，那么，很有可能就会出现只会响应A角色的操作，而B角色就始终被占用了的情况，这样，玩起来肯定就没劲了。

因此，线程是有用的，但也不是随便乱用，乱用的话，可能造成性能的低下，它是有一点的适用范围的，一般我认为：需要响应多个人的事情，从设计上需要考虑同时做一些事情（这些事情很多情况下可能一点关系都没有，也有可能有一些关系的）。

使用多线程的时候，如果某些线程之间涉及到资源共享、互相通讯等等问题的时候，一定得注意线程安全的问题，根据情况看是不是需要使用synchronized关键字。
另外,站长团上有产品团购,便宜有保证

Ⅳ 求多线程读取一个文件，然后写到另外一个文件中的Java实现。

这个是我写的三个类，用于多线程操作读取文件内容和写入文件内容，不知道是不是你合你味口。
________________第一个类______读取内容__写入内容____________________
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)+"毫秒");
}
}

Ⅳ 某公司面试题java11使用并发多线程加速下载文件，如何写

先建一个用于下载文件的多线程类，通常要指明下载文件的位置(URL)和拍胡文件名以及保存到本地的路径
public class FileDownloader implements Runnable
{
private static File file;//要下载的文件
private static String url;//文件所在URL
private static File storagePath;//保存路径
public static void initialize(File file, String url, File storagePath)//初始化静态字段，初始化的代码不用我写吧
}
然后，指明同步块，目的是让各个线程共享一个文件资源，那样它们可以知道同一个文件的下载状况(即获取其他线程下载文件到哪个位置，以防重复下载)
public synchronized void fileDownload()//此方法用于下载文件，一般的Java程序员都会写，实在不会我可以帮你补上
或者
public void fileDownload(){
synchronized(file){
synchronized(url){
synchronized(storagePath){
}}}}//给每仿贺桥个字备猛段加上同步块
run()方法的实现就以自己的喜好去写吧，只要里面调用了fileDownload()方法就行。
public void run(){
…
fileDownload();//下载文件
…
}
然后，在主类的main方法中创建一个多线程数组:
Runnable[] fds=new FileDownloader[线程数量];//fds为file_downloaders缩写
Thread[] threads=new Thread[线程数量];
最后使用循环把所有的线程逐一启动。
for(int i=0;i<线程数量;i++){
threads[i]=new Thread(fds[i]);
threads[i].start();
}

Ⅵ 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多线程实现任务分发

多线程下载由来已久 如 FlashGet NetAnts 等工具 它们都是依懒于 HTTP 协议的支持（Range 字段指定请求内容范围） 首先能读取出请求内容 （即欲下载的文件） 的大小 划分出若干区块 把区块分段分发给每个线程去下载 线程从本段起始处下载数据及至段尾 多个线程下载的内容最终会写入到同一个文件中

只研究有用的 工作中的需求 要把多个任务纳凯分派给Java的多个线程去执行 这其中就会有一个任务列表指派到线程的策略思考 已知 一个待执行的任务列表 指定要启动的线程数 问题是 每个线程实际要执行哪些任务

使用Java多线程实现这种任务分发的策略是 任务列表连续按线程数分段 先保证每线程平均能分配到的任务数 余下的任务从前至后依次附加到线程中——只是数量上 实际每个线程执行的任务都还是连续的 如果出现那种僧多（线程） 粥（任务） 少的情况 实际启动的线程数就等于任务数 一挑一 这里只实现了每个线程各扫自谨宴家门前雪 动作快的完成后眼见别的线程再累都是爱莫能助

实现及演示代码如下 由三个类实现 写在了一个 Java 文件中 TaskDistributor 为任务分发器 Task 为待执行的任务 WorkThread 为自定的工作洞晌唤线程 代码中运用了命令模式 如若能配以监听器 用上观察者模式来控制 UI 显示就更绝妙不过了 就能实现像下载中的区块着色跳跃的动感了 在此定义下一步的着眼点了

代码中有较为详细的注释 看这些注释和执行结果就很容易理解的 main（） 是测试方法

package mon;import java util ArrayList;import java util List;/*** 指派任务列表给线程的分发器* @author Unmi* QQ: Email: * MSN: */public class TaskDistributor {/*** 测试方法* @param args*/public static void main(String[] args) {//初始化要执行的任务列表List taskList = new ArrayList();for (int i = ; i < ; i++) {taskList add(new Task(i));}//设定要启动的工作线程数为 个int threadCount = ;List[] taskListPerThread = distributeTasks(taskList threadCount);System out println( 实际要启动的工作线程数 +taskListPerThread length);for (int i = ; i < taskListPerThread length; i++) {Thread workThread = new WorkThread(taskListPerThread[i] i);workThread start();}}/*** 把 List 中的任务分配给每个线程 先平均分配 剩于的依次附加给前面的线程* 返回的数组有多少个元素 (List) 就表明将启动多少个工作线程* @param taskList 待分派的任务列表* @param threadCount 线程数* @return 列表的数组 每个元素中存有该线程要执行的任务列表*/public static List[] distributeTasks(List taskList int threadCount) {// 每个线程至少要执行的任务数 假如不为零则表示每个线程都会分配到任务int minTaskCount = taskList size() / threadCount;// 平均分配后还剩下的任务数 不为零则还有任务依个附加到前面的线程中int remainTaskCount = taskList size() % threadCount;// 实际要启动的线程数 如果工作线程比任务还多// 自然只需要启动与任务相同个数的工作线程 一对一的执行// 毕竟不打算实现了线程池 所以用不着预先初始化好休眠的线程int actualThreadCount = minTaskCount > ? threadCount : remainTaskCount;// 要启动的线程数组 以及每个线程要执行的任务列表List[] taskListPerThread = new List[actualThreadCount];int taskIndex = ;//平均分配后多余任务 每附加给一个线程后的剩余数 重新声明与 remainTaskCount//相同的变量 不然会在执行中改变 remainTaskCount 原有值 产生麻烦int remainIndces = remainTaskCount;for (int i = ; i < taskListPerThread length; i++) {taskListPerThread[i] = new ArrayList();// 如果大于零 线程要分配到基本的任务if (minTaskCount > ) {for (int j = taskIndex; j < minTaskCount + taskIndex; j++) {taskListPerThread[i] add(taskList get(j));}taskIndex += minTaskCount;}// 假如还有剩下的 则补一个到这个线程中if (remainIndces > ) {taskListPerThread[i] add(taskList get(taskIndex++));remainIndces ;}}// 打印任务的分配情况for (int i = ; i < taskListPerThread length; i++) {System out println( 线程 + i + 的任务数 +

taskListPerThread[i] size() + 区间[ + taskListPerThread[i] get( ) getTaskId() + + taskListPerThread[i] get(taskListPerThread[i] size() ) getTaskId() + ] );}return taskListPerThread;}}/*** 要执行的任务 可在执行时改变它的某个状态或调用它的某个操作* 例如任务有三个状态 就绪 运行 完成 默认为就绪态* 要进一步完善 可为 Task 加上状态变迁的监听器 因之决定UI的显示*/class Task {public static final int READY = ;public static final int RUNNING = ;public static final int FINISHED = ;private int status;//声明一个任务的自有业务含义的变量 用于标识任务private int taskId;//任务的初始化方法public Task(int taskId){this status = READY;this taskId = taskId;}/*** 执行任务*/public void execute() {// 设置状态为运行中setStatus(Task RUNNING);System out println( 当前线程 ID 是 + Thread currentThread() getName()+ | 任务 ID 是 +this taskId);// 附加一个延时try {Thread sleep( );} catch (InterruptedException e) {e printStackTrace();}// 执行完成 改状态为完成setStatus(FINISHED);}public void setStatus(int status) {this status = status;}public int getTaskId() {return taskId;}}/*** 自定义的工作线程 持有分派给它执行的任务列表*/class WorkThread extends Thread {//本线程待执行的任务列表 你也可以指为任务索引的起始值private List taskList = null;private int threadId;/*** 构造工作线程 为其指派任务列表 及命名线程 ID* @param taskList 欲执行的任务列表* @param threadId 线程 ID*/public WorkThread(List taskList int threadId) {this taskList = taskList;this threadId = threadId;}/*** 执行被指派的所有任务*/public void run() {for (Task task : taskList) {task execute();}}}

执行结果如下 注意观察每个Java多线程分配到的任务数量及区间 直到所有的线程完成了所分配到的任务后程序结束

线程 的任务数 区间[ ]线程 的任务数 区间[ ]线程 的任务数 区间[ ]线程 的任务数 区间[ ]线程 的任务数 区间[ ]实际要启动的工作线程数 当前线程 ID 是 Thread | 任务 ID 是 当前线程 ID 是 Thread | 任务 ID 是 当前线程 ID 是 Thread | 任务 ID 是 当前线程 ID 是 Thread | 任务 ID 是 当前线程 ID 是 Thread | 任务 ID 是 当前线程 ID 是 Thread | 任务 ID 是 当前线程 ID 是 Thread | 任务 ID 是 当前线程 ID 是 Thread | 任务 ID 是

上面坦白来只算是基本功夫 贴出来还真见笑了 还有更为复杂的功能

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

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