Thread Specific System.out

We recently needed a multi-threaded Java program where each thread would write its output to a separate text file. Some of the code that each thread would execute was already written and writing its output to System.out. Our management did not want us to take the time to rewite the existing code, so we wrote a class named ThreadPrintStream that extends java.io.PrintStream and maintains a separate PrintStream for each thread using ThreadLocal. Then we used an object of ThreadPrintStream to replace the normal System.out.

Below you will find three classes:

Main

Creates a ThreadPrintStream, installs it as System.out, and creates and starts 10 threads.

StreamText

a simple Runnable for each thread that opens a file for the thread's output and installs it into the ThreadPrintStream.

ThreadPrintStream

extends java.io.PrintStream. An object of ThreadPrintStream replaces the normal System.out and maintains a separate java.io.PrintStream for each thread.

Main

public class Main {
	public static void main(String[] args) {
		// Call replaceSystemOut which replaces the
		// normal System.out with a ThreadPrintStream. 
		ThreadPrintStream.replaceSystemOut();

		// Create and start 10 different threads.  Each thread
		// will create its own PrintStream and install it into
		// the ThreadPrintStream and then write three messages
		// to System.out.
		for (int i = 0;  i < 10;  i++) {
			Thread thread = new Thread(new StreamText());
			thread.start();

			// Report to the console that a new thread was started.
			System.out.println("Created and started " + thread.getName());
		}
	}
}

StreamText

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.PrintStream;

/** A small test class that sets System.out for the currently executing
 * thread to a text file and writes three messages to System.out. */
public class StreamText implements Runnable {
	@Override
	public void run() {
		try {
			// Create a text file where System.out.println()
			// will send its data for this thread.
			String name = Thread.currentThread().getName();
			FileOutputStream fos = new FileOutputStream(name + ".txt");

			// Create a PrintStream that will write to the new file.
			PrintStream stream = new PrintStream(new BufferedOutputStream(fos));

			// Install the PrintStream to be used as System.out for this thread.
			((ThreadPrintStream)System.out).setThreadOut(stream);

			// Output three messages to System.out.
			System.out.println(name + ": first message");
			System.out.println("This is the second message from " + name);
			System.out.println(name + ": 3rd message");

			// Close System.out for this thread which will
			// flush and close this thread's text file.
			System.out.close();
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

ThreadPrintStream

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;

/** A ThreadPrintStream replaces the normal System.out and ensures
 * that output to System.out goes to a different PrintStream for
 * each thread.  It does this by using ThreadLocal to maintain a
 * PrintStream for each thread. */
public class ThreadPrintStream extends PrintStream {

	/** Changes System.out to a ThreadPrintStream which will
	 * send output to a separate file for each thread. */
	public static void replaceSystemOut() {

		// Save the existing System.out
		PrintStream console = System.out;

		// Create a ThreadPrintStream and install it as System.out
		ThreadPrintStream threadOut = new ThreadPrintStream();
		System.setOut(threadOut);

		// Use the original System.out as the current thread's System.out
		threadOut.setThreadOut(console);
	}

	/** Thread specific storage to hold a PrintStream for each thread */
	private ThreadLocal<PrintStream> out;

	private ThreadPrintStream() {
		super(new ByteArrayOutputStream(0));
		out = new ThreadLocal<PrintStream>();
	}

	/** Sets the PrintStream for the currently executing thread. */
	public void setThreadOut(PrintStream out) {
		this.out.set(out);
	}

	/** Returns the PrintStream for the currently executing thread. */
	public PrintStream getThreadOut() {
		return this.out.get();
	}

	@Override public boolean checkError() {
		return getThreadOut().checkError();
	}

	@Override public void write(byte[] buf, int off, int len) {
		getThreadOut().write(buf, off, len);
	}

	@Override public void write(int b) { getThreadOut().write(b); }

	@Override public void flush() { getThreadOut().flush(); }
	@Override public void close() { getThreadOut().close(); }
}

Maia L.L.C. and its employees have used their best efforts in preparing this article. These efforts include the development, research, and testing of the theories and computer programs in this article to determine their correctness. Maia L.L.C. makes no warranty of any kind, expressed or implied, with regard to these programs or the documentation contained in this article. Maia L.L.C. shall not be liable in any event for incidental or consequential damages in connection with, or arising out of, the furnishing, performance, or use of these programs.