package com.ximple.io.dgn7;
|
|
//~--- JDK imports ------------------------------------------------------------
|
|
import java.io.IOException;
|
import java.util.HashMap;
|
import java.util.Map;
|
|
import org.apache.log4j.LogManager;
|
import org.apache.log4j.Logger;
|
|
/**
|
* Lock
|
*
|
* @author Ulysses
|
* @version 0.1
|
* @since 2006/5/18 上午 10:27:24
|
*/
|
public class Lock {
|
Logger logger = LogManager.getLogger("com.ximple.io.dgn7");
|
|
/**
|
* indicates a write is occurring
|
*/
|
int writeLocks = 0;
|
|
/**
|
* if not null a writer is waiting for the lock or is writing.
|
*/
|
Thread writer;
|
|
/**
|
* Thread->Owner map. If empty no read locks exist.
|
*/
|
Map owners = new HashMap();
|
|
/**
|
* If the lock can be read locked the lock will be read and default
|
* visibility for tests
|
*
|
* @return
|
* @throws java.io.IOException
|
*/
|
synchronized boolean canRead() throws IOException {
|
if ((writer != null) && (writer != Thread.currentThread())) {
|
return false;
|
}
|
|
if (writer == null) {
|
return true;
|
}
|
|
if (owners.size() > 1) {
|
return false;
|
}
|
|
return true;
|
}
|
|
/**
|
* If the lock can be read locked the lock will be read and default
|
* visibility for tests
|
*
|
* @return
|
* @throws IOException
|
*/
|
synchronized boolean canWrite() throws IOException {
|
if (owners.size() > 1) {
|
return false;
|
}
|
|
if ((canRead()) && ((writer == Thread.currentThread()) || (writer == null))) {
|
if (owners.isEmpty()) {
|
return true;
|
}
|
|
if (owners.containsKey(Thread.currentThread())) {
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
/**
|
* Called by shapefileReader before a read is started and before an IOStream
|
* is openned.
|
*
|
* @throws IOException
|
*/
|
public synchronized void lockRead() throws IOException {
|
if (!canRead()) {
|
while ((writeLocks > 0) || (writer != null)) {
|
try {
|
wait();
|
} catch (InterruptedException e) {
|
throw (IOException) new IOException().initCause(e);
|
}
|
}
|
}
|
|
assertTrue("A write lock exists that is owned by another thread", canRead());
|
|
Thread current = Thread.currentThread();
|
Owner owner = (Owner) owners.get(current);
|
|
if (owner != null) {
|
owner.timesLocked++;
|
} else {
|
owner = new Owner(current);
|
owners.put(current, owner);
|
}
|
|
logger.debug("Start Read Lock:" + owner);
|
}
|
|
private void assertTrue(String message, boolean b) {
|
if (!b) {
|
throw new AssertionError(message);
|
}
|
}
|
|
/**
|
* Called by ShapefileReader after a read is complete and after the IOStream
|
* is closed.
|
*/
|
public synchronized void unlockRead() {
|
assertTrue("Current thread does not have a readLock", owners.containsKey(Thread.currentThread()));
|
|
Owner owner = (Owner) owners.get(Thread.currentThread());
|
|
assertTrue("Current thread has " + owner.timesLocked + "negative number of locks", owner.timesLocked > 0);
|
owner.timesLocked--;
|
|
if (owner.timesLocked == 0) {
|
owners.remove(Thread.currentThread());
|
}
|
|
notifyAll();
|
logger.debug("unlock Read:" + owner);
|
}
|
|
/**
|
* Called by ShapefileDataStore before a write is started and before an
|
* IOStream is openned.
|
*
|
* @throws IOException
|
*/
|
public synchronized void lockWrite() throws IOException {
|
Thread currentThread = Thread.currentThread();
|
|
if (writer == null) {
|
writer = currentThread;
|
}
|
|
while (!canWrite()) {
|
try {
|
wait();
|
} catch (InterruptedException e) {
|
throw (IOException) new IOException().initCause(e);
|
}
|
|
if (writer == null) {
|
writer = currentThread;
|
}
|
}
|
|
if (writer == null) {
|
writer = currentThread;
|
}
|
|
assertTrue("The current thread is not the writer", writer == currentThread);
|
assertTrue("There are read locks not belonging to the current thread.", canRead());
|
writeLocks++;
|
logger.debug(currentThread.getName() + " is getting write lock:" + writeLocks);
|
}
|
|
/**
|
* default visibility for tests
|
*/
|
synchronized int getReadLocks(Thread thread) {
|
Owner owner = (Owner) owners.get(thread);
|
|
if (owner == null) {
|
return -1;
|
}
|
|
return owner.timesLocked;
|
}
|
|
public synchronized void unlockWrite() {
|
if (writeLocks > 0) {
|
assertTrue("current thread does not own the write lock", writer == Thread.currentThread());
|
assertTrue("writeLock has already been unlocked", writeLocks > 0);
|
writeLocks--;
|
|
if (writeLocks == 0) {
|
writer = null;
|
}
|
}
|
|
logger.debug("unlock write:" + Thread.currentThread().getName());
|
notifyAll();
|
}
|
|
/**
|
* default visibility for tests
|
*/
|
synchronized boolean ownWriteLock(Thread thread) {
|
return (writer == thread) && (writeLocks > 0);
|
}
|
|
private class Owner {
|
final Thread owner;
|
int timesLocked;
|
|
Owner(Thread owner) {
|
this.owner = owner;
|
timesLocked = 1;
|
}
|
|
public String toString() {
|
return owner.getName() + " has " + timesLocked + " locks";
|
}
|
}
|
}
|
