Java Multiple One Writer Drives with Semaphores and Multithreading

I was looking for a solution for potential readers of Java, a writer.
This question intrigued me and I read Wikipedia 's entry about it.

Until now, I have reached a quality solution, or at least that is what I think.
I've set up a new github repository to put the code to use in another project if users want it.

But I am open to improvements and criticism if you wish

The pseudocode of the main class is here

AbsrtactReadersWriter abstract class {

Semaphore readCountSempaphote = new Semaphore (1);
Semaphore resourceSemaphore = new Semaphore (1, true);
Semaphore serviceQueueSemaphore = new Semaphore (1, true);
AtomicInteger readCount = new AtomicInteger (0);


final public T read () {
T data = null;
try {
// entry to read
serviceQueueSemaphore.acquire ();
readCountSempaphote.acquire ();
if (readCount.incrementAndGet () == 1) {
resourceSemaphore.acquire ();
}
serviceQueueSemaphore.release ();
readCountSempaphote.release ();
// CRITICAL SECTION Do not read
data = executeReading ();
// exit to read
readCountSempaphote.acquire ();
if (readCount.decrementAndGet () == 0) {
resourceSemaphore.release ();
}
readCountSempaphote.release ();
} catch (InterruptedException e) {
System.out.println (e.getMessage ());
}
return data;
}

// Protected Critical Section that reads the resource
protected summary T executeReading ();


public void final write (T data) {
try {
// write entry
serviceQueueSemaphore.acquire ();
resourceSemaphore.acquire ();
serviceQueueSemaphore.release ();
// CRITICAL SECTION Do Write
executeWriting (data);
// Exit write
resourceSemaphore.release ();
} catch (InterruptedException e) {
System.out.println (e.getMessage ());
}
}

// Protected Critical Section that writes to the resource
abstract protected executeWriting (T data);

}

This pseucode lacks some elements (privates, comments) of the class on the github repository, but hits the goal.

In the repository, you can also see examples and tests.

The problem of famine among readers / writers is solved by Java itself, because semaphores are created with the just parameter, which forces the blocking equity and a fifo queue on the pending threads.
I'm using an AtomicInteger to store the readcount, even if it's protected; the operation of equality may not be and does not impose a great deal of punishment

So, guys, what do you think?