Re: Using ReentrantLock

RVince wrote:


That's obviously true and very big of you to admit. I think Arved's
idea to go read the Java tutorial on concurrency was very good. There
maybe some other articles on Java concurrency that you may be able to
gain some insight from. I'm not willing explain the whole thing to you
myself. It's a large subject and an explanation would be a lot of
effort on my part. I'd be happy to answer questions about the tutorial
though, that's much less effort on my part.

To try to clear up what is going on here, this is more what I was
thinking of:

public class SynchedOutputStream extends OutputStream {

   private OutputStream out;
   private ReentrantLock lock = new ReentrantLock();

   public SynchedOutputStream( OutputStream out )
   {
     this.out = out;
   }

   @Override
   public void write( int c ) throws IOException
   {
     try {
       lock.lock();
       out.write( c );
     }
     finally {
       lock.unlock();
     }
   }

   @Override
   public void write( byte [] buf, int offset, int len )
   throws IOException
   {
       try {
       lock.lock();
       out.write( buf, offset, len );
     }
     finally {
       lock.unlock();
     }
   }
}

Notice that: the lock is private, and never made public to anyone. And
the object is fully self contained -- I use no global or static objects
to do the work. I wrap an output stream, and that's it. The output
stream could be public -- depends what the caller does with it. But
that's up to the caller, not me.

Hopefully this clears things up a bit. Note also this code was syntax
checked (which we asked you for, work or not you can still compile a
short code example), although I admit I didn't run an tests on it.

I understand that this code does not group several writes together, but
I think that's easily overcome. Just group your writes into a single
buffer (like StringBuilder) and then write the result in one go.

Also note that if you are doing logging, or tasks that require large
through put, this is a terrible idea, because your going to block all
your threads on a single IO object. Just saying.