If multiple threads call System.out.println(String) without synchronization, can the output get interleaved? Or is the write of each line atomic? The API makes no mention of synchronization, so this seems possible, or is interleaved output prevented by buffering and/or the VM memory model, etc.?
EDIT:
For example, if each thread contains:
System.out.println("ABC");
is the output guaranteed to be:
ABC
ABC
or could it be:
AABC
BC
Since the API documentation makes no mention of thread safety on the System.out object nor does the PrintStream#println(String) method you cannot assume that it is thread-safe.
However, it is entirely possible that the underlying implementation of a particular JVM uses a thread-safe function for the println method (e.g. printf on glibc) so that, in reality, the output will be guaranteed per your first example (always ABC\n then ABC\n, never interspersed characters per your second example). But keep in mind that there are lots of JVM implementations and they are only required to adhere to the JVM specification, not any conventions outside of that spec.
If you absolutely must ensure that no println calls will intersperse as you describe then you must enforce mutual exclusion manually, for example:
public void safePrintln(String s) {
synchronized (System.out) {
System.out.println(s);
}
}
Of course, this example is only an illustration and should not be taken as a "solution"; there are many other factors to consider. For example, the safePrintln(...) method above is only safe if all code uses that method and nothing calls System.out.println(...) directly.
The OpenJDK source code answers your question:
public void println(String x) {
synchronized (this) {
print(x);
newLine();
}
}
As long as you don't change the OutputStream via System.setOut it is thread safe.
Though it is thread safe you can have many threads writing to System.out such that
Thread-1
System.out.println("A");
System.out.println("B");
System.out.println("C");
Thread-2
System.out.println("1");
System.out.println("2");
System.out.println("3");
can read
1
2
A
3
B
C
among other combinations.
So to answer your question:
When you write to System.out – it acquires a lock on the OutputStream instance - it will then write to the buffer and immediately flush.
Once it releases the lock, the OutputStream is flushed and written to. There would not be an instance where you would have different strings joined like 1A 2B.
Edit to answer your edit:
That would not happen with System.out.println. Since the PrintStream synchronizes the entire function, it will fill the buffer and then flush it atomically. Any new thread coming in will now have a fresh buffer to work with.
Just to clarify, say you have two threads, one that prints "ABC" and another that prints "DEF". You will never get output like this: ADBECF, but you could get either
ABC
DEF
or
DEF
ABC
