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流会一直存在，直到程序运行结束。

不可行。
多线程能够提高效率是因为现在的cpu普遍是多核cpu, 多条线程可以在多个内核中同时执行来提高计算效率。但是计算机磁盘的磁头只有一个，即使多条线程去读也并不能提高读取效率，反而因为多线程的上下文切换问题会耗时更久。

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[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;
}
}

可行。但是处理过程中会存在并发现象，需要在代码中实现队列依次处理，才能避免。
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
* 使用Timer定时器进行同一文件的读写。
*/
public class ThreadReadWriteTimer {

static File file = new File("test.txt");

public static void main(String[] args) {
Timer timer = new Timer();
timer.scheduleAtFixedRate(new TimerTask() {

@Override
public void run() {
FileWriter out;
try {
out = new FileWriter(file, true);
// 追加写入
out.write(new Date() + "\n");
out.flush();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}, 0, 3000);
timer.scheduleAtFixedRate(new TimerTask() {

BufferedReader reader = null;

{
try {
reader = new BufferedReader(new FileReader(file));
} catch (IOException e) {
e.printStackTrace();
}
}

@Override
public void run() {
try {
System.out.println(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
}, 1000, 3000);
}
}

可以
只读取的话无所谓，有写的话需要把文件锁住
synchronize(file){
写文件
}