如何使用 Java 读取正在写入的文件？
https://stackoverflow.com/questions/4149
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
我有一个将信息写入文件的应用程序。此信息在执行后用于确定应用程序的通过/失败/正确性。我希望能够在写入文件时读取该文件，以便我可以实时进行这些通过/失败/正确性检查。
我认为这是可以做到的，但是使用 Java 时涉及到什么问题呢？如果读取赶上写入，它会等待更多的写入直到文件关闭，还是读取会在此时抛出异常？如果是后者，那我该怎么办？
我的直觉目前正在推动我走向 BufferedStreams。这是要走的路吗？
解决方案
无法使用该示例来工作 FileChannel.read(ByteBuffer) 因为它不是阻塞读取。然而，下面的代码确实可以工作：
boolean running = true;
BufferedInputStream reader = new BufferedInputStream(new FileInputStream( "out.txt" ) );
public void run() {
while( running ) {
if( reader.available() > 0 ) {
System.out.print( (char)reader.read() );
}
else {
try {
sleep( 500 );
}
catch( InterruptedException ex ) {
running = false;
}
}
}
}
当然，同样的东西可以用作计时器而不是线程，但我将其留给程序员。我仍在寻找更好的方法，但这目前对我有用。
哦，我会警告这一点：我正在使用1.4.2。是的，我知道我仍然处于石器时代。
其他提示
如果您想在写入文件时读取文件并且只读取新内容，那么以下内容将帮助您实现相同的目标。
要运行该程序，您将从命令提示符/终端窗口启动它并传递要读取的文件名。除非您终止该程序，否则它将读取该文件。
java FileReader c:\myfile.txt
当您键入一行文本时，将其从记事本中保存，您将在控制台中看到打印的文本。
public class FileReader {
public static void main(String args[]) throws Exception {
if(args.length>0){
File file = new File(args[0]);
System.out.println(file.getAbsolutePath());
if(file.exists() && file.canRead()){
long fileLength = file.length();
readFile(file,0L);
while(true){
if(fileLength<file.length()){
readFile(file,fileLength);
fileLength=file.length();
}
}
}
}else{
System.out.println("no file to read");
}
}
public static void readFile(File file,Long fileLength) throws IOException {
String line = null;
BufferedReader in = new BufferedReader(new java.io.FileReader(file));
in.skip(fileLength);
while((line = in.readLine()) != null)
{
System.out.println(line);
}
in.close();
}
}
您还可以查看用于锁定文件的一部分的 java 通道。
http://java.sun.com/javase/6/docs/api/java/nio/channels/FileChannel.html
这个功能的 FileChannel 可能是一个开始
lock(long position, long size, boolean shared)
对此方法的调用将被阻塞，直到该区域被锁定为止
我完全同意 约书亚的回应, 裁缝 适合这种情况下的工作。这是一个例子：
它每 150 毫秒在文件中写入一行，同时每 2500 毫秒读取同一个文件
public class TailerTest
{
public static void main(String[] args)
{
File f = new File("/tmp/test.txt");
MyListener listener = new MyListener();
Tailer.create(f, listener, 2500);
try
{
FileOutputStream fos = new FileOutputStream(f);
int i = 0;
while (i < 200)
{
fos.write(("test" + ++i + "\n").getBytes());
Thread.sleep(150);
}
fos.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
private static class MyListener extends TailerListenerAdapter
{
@Override
public void handle(String line)
{
System.out.println(line);
}
}
}
答案似乎是“不”……是的”。似乎没有真正的方法可以知道文件是否已打开以供另一个应用程序写入。因此，从这样的文件中读取将一直进行，直到内容耗尽为止。我采纳了迈克的建议并编写了一些测试代码：
Writer.java 将一个字符串写入文件，然后等待用户按 Enter 键，然后再将另一行写入文件。这个想法是它可以启动，然后读者可以开始查看它如何处理“部分”文件。我写的阅读器在Reader.java中。
作家.java
public class Writer extends Object
{
Writer () {
}
public static String[] strings =
{
"Hello World",
"Goodbye World"
};
public static void main(String[] args)
throws java.io.IOException {
java.io.PrintWriter pw =
new java.io.PrintWriter(new java.io.FileOutputStream("out.txt"), true);
for(String s : strings) {
pw.println(s);
System.in.read();
}
pw.close();
}
}
阅读器.java
public class Reader extends Object
{
Reader () {
}
public static void main(String[] args)
throws Exception {
java.io.FileInputStream in = new java.io.FileInputStream("out.txt");
java.nio.channels.FileChannel fc = in.getChannel();
java.nio.ByteBuffer bb = java.nio.ByteBuffer.allocate(10);
while(fc.read(bb) >= 0) {
bb.flip();
while(bb.hasRemaining()) {
System.out.println((char)bb.get());
}
bb.clear();
}
System.exit(0);
}
}
不保证此代码是最佳实践。
这就留下了迈克建议的定期检查是否有新数据要从文件中读取的选项。然后，当确定读取完成时，需要用户干预来关闭文件读取器。或者，读者需要了解文件的内容并能够确定写入条件的结束。如果内容是 XML，则可以使用文档结尾来表示这一点。
本身不是 Java，但您可能会遇到问题，您已将某些内容写入文件，但尚未实际写入 - 它可能位于某处的缓存中，并且从同一个文件读取实际上可能不会给您提供新信息。
简短版本 - 使用flush()或任何相关的系统调用来确保您的数据实际写入文件。
注意我不是在谈论操作系统级磁盘缓存 - 如果您的数据进入此处，它应该出现在此时之后的 read() 中。语言本身可能会缓存写入，等待缓冲区填满或文件被刷新/关闭。
有一个开源 Java Graphic Tail 可以做到这一点。
https://stackoverflow.com/a/559146/1255493
public void run() {
try {
while (_running) {
Thread.sleep(_updateInterval);
long len = _file.length();
if (len < _filePointer) {
// Log must have been jibbled or deleted.
this.appendMessage("Log file was reset. Restarting logging from start of file.");
_filePointer = len;
}
else if (len > _filePointer) {
// File must have had something added to it!
RandomAccessFile raf = new RandomAccessFile(_file, "r");
raf.seek(_filePointer);
String line = null;
while ((line = raf.readLine()) != null) {
this.appendLine(line);
}
_filePointer = raf.getFilePointer();
raf.close();
}
}
}
catch (Exception e) {
this.appendMessage("Fatal error reading log file, log tailing has stopped.");
}
// dispose();
}
我从未尝试过，但您应该编写一个测试用例，看看在到达末尾后从流中读取是否有效，无论是否有更多数据写入文件。
有什么原因不能使用管道输入/输出流吗？数据是否是从同一个应用程序写入和读取的（如果是，那么您已经拥有数据，为什么需要从文件中读取）？
否则，也许会读到文件末尾，然后监视更改并寻找您上次停下的地方并继续...但要注意比赛条件。
您无法读取使用 FileInputStream、FileReader 或 RandomAccessFile 从另一个进程打开的文件。
但是直接使用 FileChannel 就可以了：
private static byte[] readSharedFile(File file) throws IOException {
byte buffer[] = new byte[(int) file.length()];
final FileChannel fc = FileChannel.open(file.toPath(), EnumSet.of(StandardOpenOption.READ));
final ByteBuffer dst = ByteBuffer.wrap(buffer);
fc.read(dst);
fc.close();
return buffer;
}
