如何从多线程应用程序打印到同一行

Question

I was using this code to notify the user of when REST interfaces had become available:

Console.printTermNoBreak("Waiting for interface on host [" + localTarget.getHostName() + "]");

When the interface came up then it would print 'OK' with a time stamp of how long it took to come up:

Console.SYS_LOGGER.info("[OK]" + " (" + (endTime - startTime + "ms") + ")");

On the console that would look as follows:

Waiting for interface on host [dubengvm272]         [OK] (413ms)

So both appenders write to the same line. I have refactored the code so that multiple threads bring up different interfaces on different machines.

Now because all the threads finish at different times the console is all garbled. Just wondering if I can print out in the same way as before, even if it doesn't reflect exactly what is happening in the background.

Answer 1

If you want atomicity on a line-by-line basis you need to write out your line in one go. If your line consists of multiple parts you will need to first accumulate those parts into a single line and then write out that line when it's ready.

But there are additional issues, even if individual threads write out complete lines at once you can still end up with lines overlapping each other. For example this can happen with buffered IO where the buffered writer is not thread-safe or when the line is large enough to exceed the buffer size and thus has to be broken down internally and written in multiple steps.

At least on linux writing to files/pipes opened with O_APPEND affords you some atomicity, but that's that's platform-specific, comes with some caveats and doesn't solve the buffering issue.

A more general solution for logging is to push your log items as a whole onto a thread-safe queue and have one thread poll from the queue and write to your output, item by item. That way you can also have multi-line items.

Having a separate logger thread also improves performance because logging is IO and can incur unnecessary latency on your main codepath. That way the logger thread becomes a "victim thread" for the IO penalty.

LinkedTransferQueue is a good candidate for the queue since submission to the queue does not block through a shared lock. A potential downside that it is unbounded and can potentially cause OOMs in situations where the logger thread cannnot keep up with the log submitters. But if that happens you probably have some kind of problem anyway.

If your logger is already thread-safe then you simply have to write out your output in a single line instead of two separate log calls.