Đồng bộ dữ liệu khi truy xuất tập tin với Java

Code 1
package semaphoreapp;
/** <summary>
* The Sync class represents a Synchronization Object.
* </summary>
*/
public interface Sync {
void acquire() throws InterruptedException;
void release();
boolean attempt(long msec) throws InterruptedException;
}

Code 3
package semaphoreapp;
/** <summary>
* The ReadWriteLock class represents a Read/Write Lock Object.
* </summary>
*/
public interface ReadWriteLock {
ync readLock();
Sync writeLock();
}

Code 2
package semaphoreapp;
/** <summary>
* The Semaphore class represents a Semaphore Synchronization Resource Object.
* </summary>
*/
public class Semaphore implements Sync {
protected long permits;
// current number of available permits

public Semaphore(long initialPermits) {
permits = initialPermits; }
public synchronized void release() {
++permits;
notify(); }
public void acquire() throws InterruptedException {
if (Thread.interrupted()) throw new InterruptedException();
synchronized(this) {
try {
while (permits <= 0) wait();
--permits; }
catch (InterruptedException ie) {
notify();
throw ie; } } }
public boolean attempt(long secs)throws InterruptedException{
if (Thread.interrupted()) throw new InterruptedException();
synchronized(this) {
if (permits > 0) {
// same as acquire but messier
--permits;
return true;
} else if (msecs <= 0)
// avoid timed wait if not needed
return false;
else {
try {
long startTime = System.currentTimeMillis();
long waitTime = msecs;
for (;;) {
wait(waitTime);
if (permits > 0) {
--permits;
return true; }
else {
// check for time-out
long now = System.currentTimeMillis();
waitTime = msecs - (now - startTime);
if (waitTime <= 0)
return false; } } }
catch(InterruptedException ie) {
notify();
throw ie; } } } } }

Code 4
package semaphoreapp;
/** <summary>
* The SemReadWriteLock class represents a Object Semaphore Read/Write Lock.
* </summary>
*/
public class SemReadWriteLock implements ReadWriteLock {
// Provide fair access to active slot
Sync active_ = new Semaphore(1);
// Control slot sharing by readers
class ReaderGate implements Sync {
int readers_ = 0;
public synchronized void acquire()
throws InterruptedException {
// readers pile up on lock until first passes
if (readers_++ == 0) active_.acquire(); }
public synchronized void release() {
if (--readers_ == 0) active_.release(); }
public synchronized boolean attempt(long msec)
throws InterruptedException {
if (readers_++ == 0) {
return active_.attempt(msec);
} else {
return true; }
} }
Sync rGate_ = new ReaderGate();
public Sync writeLock() { return active_; }
public Sync readLock() { return rGate_; } }

Code 5
package semaphoreapp;
/** <summary>
* The FileManager class represents a FileManager Object.
* </summary>
*/
public interface FileManager {
SemReadWriteLock oSemaphore = new SemReadWriteLock(); }

Code 6
public class A implements FileManager{
//before read
oSemaphore.readLock().acquire();
//do reading
;
//finish reading
oSemaphore.readLock().release();
}
public class B implements FileManager{
//before write
oSemaphore.writeLock().acquire();
//do writing
;
//finish writing
oSemaphore.writeLock().release();
}