Question

Suppose we have some resource(a file on disk) in which we have to write bytes produced by different threads. These threads are spawned by some process that listens to some events and spawns a thread every time when event occures. As we have only one resource, we have to synchronize methods of the class which performs write operation:

    synchronized void write(byte [] bytes) {
       //write data to file
    }

or create some mutex:

Object mutex = new Object();
void write(byte [] bytes) {
   synchronized(mutex) {
      //write data to file
   }
}

And now suppose that we have very old hard drive, so it performs write operation too slowly. And several times a day we have very large amount of events occured. So the threads will make something like queue to the resource. So I have next questions:

1. How long such queue could be?
2. If there are several threads waiting for the resource and resource
   has freed what thread will be the first to occupy the resource. Will
   it be FIFO principle?
3. How the situation will change if threads have different priorities?
4. If the resource is DataSource object which produces Connection object participating in connection pooling, will it be the same as with the file above?

Answer 1

1. The length of the queue is the number of blocked threads. If you keep creating threads and they all finish being blocked in writing, you’ll quickly bring the system to its knees. You should certainly use a thread pool, reuse threads instead of creating them, and block once too many events are in the queue. See Executors.
2. No, it’s not FIFO. The order is undefined. You might want to use a fair ReentrantLock if you want FIFO. But it’s more time-consuming tha basic synchronization or an unfair lock.
3. Platform-dependant, and no deterministic behaviour.
4. It all depends on the implementation of the datasource. It might use a fair algorithm or simply use a fair lock. Or it might just use synchronization and not be fair. You need to read the doc of the datasource, if sufficiently detailed.