Streams with multiple writers

Question

Here is a conundrum I've been unable to solve:
How do multiple threads write to a PrintWriter, and then disconnect without killing each other?
Here's the long version:
Consider a thread with two pipes:
PipedInputReader p1in = new PipedInputReader();
PipedOutputWriter p1out = new PipedOutputWriter(p1in);For speed, efficiency, and the desire to use the readline() method, this thread wants to wrap the input with a buffer:
BufferedReader in = new BufferedReader(p1in);Now, this thread wants to give access to the other end of the pipe to someone else, and wrap it in a BufferedWriter. In turn, that will be wrapped in an autoflushed PrintWriter so that we can use the println() method:
PrintWriter out = new PrintWriter(new BufferedWriter(p1out), true);Now we just need to give that to the outside world:
public PrintWriter getBuffer() {
return out
}Putting it all into a complete class (that may not be runnable due to typos; I'm doing this by hand), we get the following:
class buf implements Runnable {
  private PrintWriter out = null;
  public PrintWriter getBuffer() {
    return out
  public void run() {
    PipedInputReader p1in = new PipedInputReader();
    PipedOutputWriter p1out = new PipedOutputWriter(p1in);
    BufferedReader in = new BufferedReader(p1in);
    PrintWriter out = new PrintWriter(new BufferedWriter(p1out), true);
    String text = "";
    while ( (text = in.readline()) == true ) {  ;;;; }
  }Of course, toss in the try/catch blocks and all that. I probably missed a keyword here and there; eclipse does that for me :)
Now, this works remarkably well. 20 threads can call getBuffer on that thread and write to it, and everything is synchronized nicely. It really does work well enough for my needs.
However, when one of those threads exits, all the pipes close and everyone dies.
Say I have another thread that does the following:
PrintWriter xx = thethreadabove.getBuffer();I would think that somewhere along the line, when that thread is done, I can just do:
xx = null;And let the thread exit. I'd be wrong, however. It makes everything die. So, what can I do?
How can I have multiple writers with just a single reader? I am not locked into pipes wrapped by bufferedwriters wrapped by printwriters; they just provide what I need with little issue. I'm guessing someone will tell me at some point that I was supposed to use a queue of some sort (arrayblockingqueue, etc.), and I'm sure that might work with enough spit and tape. Streams should work too, though, shouldn't they? I should be able to remove one of many references to a PrintWriter without killing the underlying pipe, right?

Answer 1

Ok, so here's what I found. First, I had the reader thread export a PrintWriter by doing the following:
private MyBuffer outside
public ReaderThread() {
  outside = new MyBuffer(new BufferedReader(pipe))
public PrintWriter getBuffer() {
  outside.register();
  return (new PrintWriter(outside))
}The MyBuffer class is then:
public class MyBuffer extends FilterWriter {
  private int count = 0;
  public MyBuffer(Writer w) {
    super(w);
  public void register() {
    ++count;
  public void close() {
    --count;
    if (count <= 0)
      super.close();
}I couldn't for the life of me get that close method to be called. Even if I called it manually, things still fell apart, because after about 1 second, the pipe would close.
Here's what I found:
Pipes have a nice undocument / poorly documented feature wherein they will close 1 second after the last thread that wrote to the pipe exits. Crazy, eh? Pipes expect one and only one thread to do the writing, and have a rather lousy mechanism for even achieving that goal (proven by how I worked around it). They record the thread id of the last thread to write to the pipe. So if I have the aforementioned 20 worker threads that all get a pointer to the printwriter encapsulating the buffer encapsulating the pipe, and they each write to the printwriter, each write will change the value of the thread id that the pipe is looking for. If one of those threads dies and is listed as the last thread to conduct a write, then the whole pipe shuts down, causing a ripple effect of broken pipes.
This is a very inneffective design, and even the source code for the java sdk contains comments saying that there should be a better way. Until that ever gets fixed, I'm left with having to signal another thread to do a write before the dying thread can terminate. This is not very safe in the case of a real problem with a given thread, but at least it works in terms of the "go-path".
Craziness.
If anyone can think of a good way to handle this, I'm open. I'm thinking write now that I need a separate thread to do the watching, and dying threads need to signal that thread to take over as the "last writer". Either that, or maybe work up an event listener to trigger on every write. I really don't know. This is disappointing really.