在多线程 Java 程序中，每个线程都有自己的 System.out 副本吗？

是否可以在“每线程”的基础上重定向 System.out

不，这是不可能的。 是静态的，并且每个 JVM 都有一个，当 JVM 最初引导时，它作为系统类装入器的一部分进行装入。虽然当然建议对每个线程使用正确的日志记录调用，但我认为有原因导致您无法执行此操作。可能第三方库或其他代码是以这种方式使用的。System.outSystem.out

你可以做的一件事（作为一个激进的建议）是让自己的委托给一个.但是，您需要应用程序调用的适当方法来使其按线程工作。PrintStreamThreadLocal<PrintStream>@Override

最后，如果您因为担心并发性而问这个问题，那么它已经处于掩护之下，并且可以由多个线程安全地使用。System.outPrintStreamsynchronized

是否可以在“每线程”的基础上重定向 System.out

来自Maia公司的一些开发人员提供了PrintStream的公共实现，该实现在本文中为每个线程提供一个“STDOUT”：“线程特定系统.out”。

在他们的实现中，它们只重写写方法，刷新，关闭和检查错误。在他们的情况下，这似乎足够了。

他们并不像@Gray在他的答案中所说的那样“需要@Override所有调用的方法才能使其按线程工作”。

诺塔：

请在下面找到Maia的原始代码。

我在时光机上找到了它。原始页面已从Maia网站上删除。我在这里复制它是为了读者的好奇心。我不为此代码提供任何支持。

主要.java

创建一个 ThreadPrintStream，将其作为 System.out 安装，然后创建并启动 10 个线程。

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());
    }
  }
}

流文本.java

每个线程的简单 Runnable，它为线程的输出打开一个文件并将其安装到 ThreadPrintStream 中。

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.java

Extends java.io.PrintStream.ThreadPrintStream 的对象取代了正常的 System.out，并为每个线程维护一个单独的 java.io.PrintStream。

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(); }
}