在 Java FileOutputStream 对象上从多个线程调用 write 是否安全？输出会被正确序列化吗？
澄清：
在我的例子中，类记录器持有一个 FileOutputStream 引用，并且多个线程可以调用记录器写入，它格式化输出并调用 FileOutputStream 写入。
我是否应该同步我的记录器写入方法以保证来自多个线程的消息不混合？
【问题讨论】：
一个文件在write-mode中不能多次打开，所以答案是否定的。
看到您的编辑后，是的，您应该在记录器中引入同步，以确保一次只能由一个线程访问流。只是一个建议，你为什么不去Log4J？它已经处理了您的用例。
【讨论】：
这是一个使用 java nio FileChannel 的同步记录器的简单实现。 在此示例中，日志消息限制为 1024 字节。您可以通过更改 BUFFER_SIZE 值来调整日志消息长度。
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.HashMap;
/**
* The MyLogger class abstracts the writing of log messages to a file.
* This is a synchronized implementation due to the usage of java.nio.channels.FileChannel
* which is used to write log messages to the log file.
*
* The MyLogger class maintains a HashMap of MyLogger instances per log file.
* The Key is the MD5 hash of the log file path and the Value is the MyLogger instance for that log file.
*
*/
public final class MyLogger {
private static final int BUFFER_SIZE = 1024;
private static final int DIGEST_BASE_RADIX = 16;
private static final String LINE_SEPARATOR = System.getProperty("line.separator");
private static HashMap<String, MyLogger> sLoggerMap;
private FileChannel mLogOutputChannel;
private ByteBuffer mByteBuffer;
private String mLogDir;
private String mLogFileName;
/**
* Private constructor which creates our log dir and log file if they do not already already exist.
* If the log file exists, then it is opened in append mode.
*
* @param logDir
* The dir where the log file resides
* @param logFileName
* The file name of the log file
* @throws IOException
* Thrown if the file could not be created or opened for writing.
*/
private MyLogger(String logDir, String logFileName) throws IOException {
mLogDir = logDir;
mLogFileName = logFileName;
// create the log dir and log file if they do not exist
FileOutputStream logFile;
new File(mLogDir).mkdirs();
final String logFilePath = mLogDir + File.separatorChar + mLogFileName;
final File f = new File(logFilePath);
if(!f.exists()) {
f.createNewFile();
}
logFile = new FileOutputStream(logFilePath, true);
// set up our output channel and byte buffer
mLogOutputChannel = logFile.getChannel();
mByteBuffer = ByteBuffer.allocate(BUFFER_SIZE);
}
/**
* Writes the given log message to the log file that is represented by this MyLogger instance.
* If the log message could not be written to the log file an error is logged in the System log.
*
* @param logMessage
* The log message to write to the log file.
*/
public void log(String logMessage) {
// write the log message to the log file
if (mLogOutputChannel != null) {
mByteBuffer.put(logMessage.getBytes());
mByteBuffer.put(LINE_SEPARATOR.getBytes());
mByteBuffer.flip();
try {
mLogOutputChannel.write(mByteBuffer);
// ensure that the data we just wrote to the log file is pushed to the disk right away
mLogOutputChannel.force(true);
} catch (IOException e) {
// Could not write to log file output channel
e.printStackTrace();
return;
}
}
if(mByteBuffer != null) {
mByteBuffer.clear();
}
}
/**
* Get an instance of the MyLogger for the given log file. Passing in the same logDir and logFileName will result in the same MyLogger instance being returned.
*
* @param logDir
* The directory path where the log file resides. Cannot be empty or null.
* @param logFileName
* The name of the log file Cannot be empty or null.
* @return The instance of the MyLogger representing the given log file. Null is returned if either logDir or logFilename is null or empty string.
* @throws IOException
* Thrown if the file could not be created or opened for writing.
*/
public static MyLogger getLog(String logDir, String logFileName) throws IOException {
if(logDir == null || logFileName == null || logDir.isEmpty() || logFileName.isEmpty()) {
return null;
}
if(sLoggerMap == null) {
sLoggerMap = new HashMap<String, MyLogger>();
}
final String logFilePathHash = getHash(logDir + File.separatorChar + logFileName);
if(!sLoggerMap.containsKey(logFilePathHash)) {
sLoggerMap.put(logFilePathHash, new MyLogger(logDir, logFileName));
}
return sLoggerMap.get(logFilePathHash);
}
/**
* Utility method for generating an MD5 hash from the given string.
*
* @param path
* The file path to our log file
* @return An MD5 hash of the log file path. If an MD5 hash could not be generated, the path string is returned.
*/
private static String getHash(String path) {
try {
final MessageDigest digest = MessageDigest.getInstance("MD5");
digest.update(path.getBytes());
return new BigInteger(digest.digest()).toString(DIGEST_BASE_RADIX);
} catch (NoSuchAlgorithmException ex) {
// this should never happen, but just to make sure return the path string
return path;
}
}
}
这就是你将如何使用它：
MyLogger aLogger = MyLogger.getLog("/path/to/log/dir", "logFilename");
aLogger.log("my log message");
【讨论】：
没有。 Java 不支持从多个线程流式传输到同一个流。
如果您想使用线程流，请查看此站点：http://lifeinide.com/post/2011-05-25-threaded-iostreams-in-java/
他很好地解释了事情，并且有一些ThreadedOutputStream 的示例代码，可以满足您的需求。
【讨论】：
如果您想保持排序（即输出流中的消息 1 位于消息 2 之前），您必须锁定流。这反过来又降低了并发性。 （所有线程都将在锁/信号量队列中排队，并在那里等待流可供它们使用）
如果您只对并发写入流感兴趣并且不关心排序，则可以为每个线程设置缓冲区。每个线程都写入自己的缓冲区。当缓冲区已满时，它会在流上获取一个锁（这可能涉及等待锁）并将其内容清空到流中。
编辑： 我刚刚意识到，如果您关心排序并且仍然想要多线程，如果您还以 unix 格式（作为 long）在输出流中写入时间。将流刷新到其他容器后，可以根据时间对内容进行排序，您应该有一个有序的文件。
【讨论】：