jvn.JvnObjectImpl Class Reference

Inheritance diagram for jvn.JvnObjectImpl:

[legend]

Collaboration diagram for jvn.JvnObjectImpl:

[legend]

List of all members.

Public Member Functions
	JvnObjectImpl (Serializable o)
void	jvnLockRead () throws JvnException
void	jvnLockWrite () throws JvnException
void	jvnUnLock () throws JvnException
int	jvnGetObjectId () throws JvnException
void	jvnSetObjectId (int id) throws JvnException
Serializable	jvnGetObjectState () throws JvnException
void	jvnInvalidateReader () throws JvnException
Serializable	jvnInvalidateWriter () throws JvnException
Serializable	jvnInvalidateWriterForReader () throws JvnException
Protected Attributes
Serializable	__containedObject = null
Package Attributes
JvnObjectState	__containedObjectLockState = null
Private Attributes
int	numberOfReadLocks = -1
int	jvnObjectId = -1
Static Private Attributes
static final long	serialVersionUID = -1348964285294975085L

---

Detailed Description

This class implements the Javanaise Object.

Definition at line 17 of file JvnObjectImpl.java.

---

Constructor & Destructor Documentation

jvn.JvnObjectImpl.JvnObjectImpl

(

Serializable

o

)

Constructor based on a serializable object. Once constructed, it will also take a write lock on the object. NOTE: removed "throws JvnException" because there's nothing that could trigger it, and most of all, it wreaks havoc in Jvn2: * this exception cannot be caught, as the call to another constructor (from super or this) must be the first instruction in a constructor... * judging from the example, JvnException is not supposed to be thrown by the Jvn* constructors.

Definition at line 71 of file JvnObjectImpl.java.

References jvn.JvnObjectImpl.__containedObject, jvn.JvnObjectImpl.__containedObjectLockState, and jvn.JvnObjectImpl.numberOfReadLocks.

                                                                       {
                __containedObject = o;
                numberOfReadLocks = 0;
                __containedObjectLockState = JvnObjectState.STATE_WLOCKT;
        }

---

Member Function Documentation

void jvn.JvnObjectImpl.jvnLockRead

(

)

throws JvnException

Obtains a read lock on the Javanaise object:

• If it already has a read lock (cached or a real lock), it will locally lock the object (no calls to the server or the Javanaise Coordinator is done)
• If it doesn't have such a lock, it will ask the server to obtain a read lock, using the JvnServerImpl#jvnLockRead(int) method. The current object state returned by that method will be saved.

TODO: Read lock requests should wait if some write locks or unlocks are pending, otherwise we risk starvation. Note that the wait also needs to be propagated to the Javanaise Coordinator as well as all the other Javanaise servers that have a read lock on the Javanaise object.

Implements jvn.JvnObject.

Definition at line 92 of file JvnObjectImpl.java.

References jvn.JvnObjectImpl.__containedObject, jvn.JvnObjectImpl.__containedObjectLockState, jvn.JvnObjectImpl.jvnObjectId, and jvn.JvnObjectImpl.numberOfReadLocks.

                                                      {
                // Only process one lock request at a time
                synchronized(__containedObjectLockState) {
                        // Whether we should ask the server for the read lock or not
                        // Asking needs to be done OUTSIDE a synchronized block (deadlock)
                        boolean askServer = false;

                        synchronized(this) {
                                if( __containedObjectLockState == JvnObjectState.STATE_RLOCKC ) {
                                        // We already have a cached read lock
                                        numberOfReadLocks = 1;
                                        __containedObjectLockState = JvnObjectState.STATE_RLOCKT;
//                                      System.out.println("Read lock: upgrading from \"cached\" to \"taken\".");
                                } else if( __containedObjectLockState == JvnObjectState.STATE_RLOCKT ) {
                                        // We already have a lock: simply increment reference count
                                        numberOfReadLocks++;
//                                      System.out.println("Read lock: one more reader (total: "+numberOfReadLocks+")");
                                } else {
                                        // We don't have any read lock, ask the server
//                                      System.out.println("Read lock: obtaining via server");
                                        askServer = true;
                                }
                        }

                        // Ask the server if needed
                        if(askServer){
                                Serializable temp = JvnServerImpl.jvnGetServer().jvnLockRead(jvnObjectId);

                                // Ask server OK, now resync and update datum
                                synchronized(this) {
                                        if(temp==null) {
                                                throw new JvnException("Invalid object received when asking for read lock!");
                                        } else {
                                                numberOfReadLocks = 1;
                                                __containedObject = temp;
                                                __containedObjectLockState = JvnObjectState.STATE_RLOCKT;
//                                              System.out.println("Read lock: obtained via server");
                                        }
                                }
                        }
                }
        }

void jvn.JvnObjectImpl.jvnLockWrite

(

)

throws JvnException

Obtains a write lock on the Javanaise object:

• If it already has a cached write lock, it will locally lock the object (no calls to the server or the Javanaise Coordinator is done)
• If it doesn't have such a lock, it will ask the server to obtain a write lock, using the JvnServerImpl#jvnLockWrite(int) method. The current object state returned by that method will be saved.

Implements jvn.JvnObject.

Definition at line 144 of file JvnObjectImpl.java.

References jvn.JvnObjectImpl.__containedObject, jvn.JvnObjectImpl.__containedObjectLockState, and jvn.JvnObjectImpl.jvnObjectId.

                                                       {
                // Only process one lock request at a time
                synchronized(__containedObjectLockState) {
                        // Whether we should ask the server for the write lock or not
                        // Asking needs to be done OUTSIDE a synchronized block (deadlock)
                        boolean askServer = false;

                        synchronized(this) {
                                if( __containedObjectLockState == JvnObjectState.STATE_WLOCKC ) {
                                        // We already have a write lock cached
                                        __containedObjectLockState = JvnObjectState.STATE_WLOCKT;
//                                      System.out.println("Write lock: upgrading from \"cached\" to \"taken\".");
                                } else {
                                        // The server will contact the coordinator if required
//                                      System.out.println("Write lock: obtaining via server");
                                        askServer = true;
                                }
                        }

                        // Ask the server if needed
                        if(askServer) {
                                Serializable temp = JvnServerImpl.jvnGetServer().jvnLockWrite(jvnObjectId);

                                // Ask server OK, now resync and update datum
                                synchronized(this) {
                                        if( temp!=null ) {
                                                __containedObject = temp;
                                                __containedObjectLockState = JvnObjectState.STATE_WLOCKT;
//                                              System.out.println("Write lock: obtained via server");
                                        } else {
                                                throw new JvnException("Invalid object received when asking for write lock!");
                                        }
                                }
                        }
                }
        }

void jvn.JvnObjectImpl.jvnUnLock

(

)

throws JvnException

Unlocks the current lock, whether read or write.

• If the object is write-locked, it transforms the write lock into a cached write lock.
• If the object is read-locked, it decreases the read lock count by one and if the read lock count is 0 then the read lock is transformed into a cached read lock.

Unlocking a locking doesn't necessarily generate a call on the Javanaise Server or Coordinator. It will probably generate one if requests are pending.

Implements jvn.JvnObject.

Definition at line 194 of file JvnObjectImpl.java.

References jvn.JvnObjectImpl.__containedObjectLockState, and jvn.JvnObjectImpl.numberOfReadLocks.

Referenced by irc.IrcJvn2.main(), and counter.CounterJvn2.main().

                                                    {
                synchronized(this)
                {
                        // Perform the change locally: see "Cohérence: cas de figure 1".
                        if (__containedObjectLockState == JvnObjectState.STATE_WLOCKT) {
                                __containedObjectLockState = JvnObjectState.STATE_WLOCKC;
//                              System.out.println("Write lock: downgrading from \"taken\" to \"cached\".");

                                // Wake threads that are lazily sleeping.
                                this.notifyAll();
                        } else if (__containedObjectLockState == JvnObjectState.STATE_RLOCKT) {
                                numberOfReadLocks--;
//                              System.out.println("Read lock: one less reader (total: "+numberOfReadLocks+")");

                                if( numberOfReadLocks <= 0 ) {
                                        // No more read locks left: set lock status as "read lock
                                        // cached" and notify people that are waiting
//                                      System.out.println("Read lock: downgrading from \"taken\" to \"cached\".");
                                        __containedObjectLockState = JvnObjectState.STATE_RLOCKC;
                                        this.notifyAll();
                                }
                        } else {
                                throw new JvnException("Tried to unlock an object that's not locked !?!");
                        }
                }
        }

Here is the caller graph for this function:

int jvn.JvnObjectImpl.jvnGetObjectId

(

)

throws JvnException

Gets the Javanaise Object ID.

Returns:

The Javanaise Object ID.

Implements jvn.JvnObject.

Definition at line 226 of file JvnObjectImpl.java.

References jvn.JvnObjectImpl.jvnObjectId.

                                                        {
                if( jvnObjectId <= 0 ) {
                        throw new JvnException("Current Javanaise Object ID is invalid!");
                } else {
                        return jvnObjectId;
                }
        }

void jvn.JvnObjectImpl.jvnSetObjectId

(

int

id

)

throws JvnException

Sets the Javanaise Object ID.

Parameters:

id

: The Javanaise Object ID.

Implements jvn.JvnObject.

Definition at line 239 of file JvnObjectImpl.java.

References jvn.JvnObjectImpl.jvnObjectId.

                                                               {
                if( id <= 0 ) {
                        throw new JvnException("Invalid Javanaise Object ID!");
                } else {
                        jvnObjectId = id;
                }
        }

Serializable jvn.JvnObjectImpl.jvnGetObjectState

(

)

throws JvnException

Gets the current state of the Javanaise Object. Note that the programmer is responsible for doing a read or write lock before calling this method.

See also:

JvnObjectImpl.jvnLockRead()

JvnObjectImpl.jvnLockWrite()

Returns:

The current state of the Javanaise Object.

Implements jvn.JvnObject.

Definition at line 256 of file JvnObjectImpl.java.

References jvn.JvnObjectImpl.__containedObject, and jvn.JvnObjectImpl.__containedObjectLockState.

                                                                    {
                if( __containedObjectLockState != JvnObjectState.STATE_RLOCKT &&
                        __containedObjectLockState != JvnObjectState.STATE_WLOCKT ) {
                        throw new JvnException("Please make sure you obtain a read or write lock BEFORE getting the object state!");
                } else {
                        return __containedObject;
                }
        }

void jvn.JvnObjectImpl.jvnInvalidateReader

(

)

throws JvnException

Invalidates a read lock. Once this method has finished, the object lock state is JvnObjectState.STATE_NOLOCK

This is normally called by the Javanaise Server, itself propagating a call received from the Javanaise Coordinator.

Implements jvn.JvnObject.

Definition at line 272 of file JvnObjectImpl.java.

References jvn.JvnObjectImpl.__containedObjectLockState.

                                                              {
                synchronized(this) {
                        if( __containedObjectLockState == JvnObjectState.STATE_RLOCKT ) {
//                              System.out.println("Invalidating reader: current state is \"taken\" ("+numberOfReadLocks+" readers).");
                                try {
                                        // Wait while not ready.
                                        while( __containedObjectLockState == JvnObjectState.STATE_RLOCKT ) {
                                                this.wait();
                                        }
                                } catch (InterruptedException e) {
                                        throw new JvnException( "InterruptedException has occured while invalidating reader!\n" + e);
                                }

                                __containedObjectLockState = JvnObjectState.STATE_NOLOCK;
                        } else if( __containedObjectLockState == JvnObjectState.STATE_RLOCKC ) {
//                              System.out.println("Invalidating reader: current state is \"cached\".");
                                __containedObjectLockState = JvnObjectState.STATE_NOLOCK;
                        } else {
                                // Don't throw this: we sometimes have some small sync issues
                                // for states (duplicate messages are sent), but it's ignorable
//                              throw new JvnException( "Tried to invalidate a reader but object state is not a reading state, it is: " + __containedObjectLockState );
                        }

//                      System.out.println("Reader invalidation OK: current state is \"no lock\".");
                }
        }

Serializable jvn.JvnObjectImpl.jvnInvalidateWriter

(

)

throws JvnException

Invalidates a write lock. Once this method has finished, the object lock state is JvnObjectState.STATE_NOLOCK

This is normally called by the Javanaise Server, itself propagating a call received from the Javanaise Coordinator.

Returns:

Current state of the Javanaise Object, which will be sent to the Javanaise Coordinator and to the other Javanaise Servers and Clients.

Implements jvn.JvnObject.

Definition at line 309 of file JvnObjectImpl.java.

References jvn.JvnObjectImpl.__containedObject, and jvn.JvnObjectImpl.__containedObjectLockState.

                                                                      {
                synchronized(this) {
                        if( __containedObjectLockState == JvnObjectState.STATE_WLOCKT ) {
//                              System.out.println("Invalidating writer: current state is \"taken\".");
                                try {
                                        // Wait while not ready.
                                        while( __containedObjectLockState == JvnObjectState.STATE_WLOCKT ) {
                                                this.wait();
                                        }
                                } catch (InterruptedException e) {
                                        throw new JvnException( "InterruptedException has occured while invalidating writer!\n" + e);
                                }

                                __containedObjectLockState = JvnObjectState.STATE_NOLOCK;
                        } else if( __containedObjectLockState == JvnObjectState.STATE_WLOCKC ) {
//                              System.out.println("Invalidating writer: current state is \"cached\".");
                                __containedObjectLockState = JvnObjectState.STATE_NOLOCK;
                        } else {
                                // Don't throw this: we sometimes have some small sync issues
                                // for states (duplicate messages are sent), but it's ignorable
//                              throw new JvnException( "Tried to invalidate a writer but object state is not a writing state, it is: " + __containedObjectLockState );
                        }

//                      System.out.println("Writer invalidation OK: current state is \"no lock\".");
                        return __containedObject;
                }
        }

Serializable jvn.JvnObjectImpl.jvnInvalidateWriterForReader

(

)

throws JvnException

Invalidates a write lock and transforms the lock into a read lock. Once this method has finished, the object lock state is JvnObjectState.STATE_NOLOCK

This is normally called by the Javanaise Server, itself propagating a call received from the Javanaise Coordinator.

Returns:

Current state of the Javanaise Object, which will be sent to the Javanaise Coordinator and to the other Javanaise Servers and Clients.

Implements jvn.JvnObject.

Definition at line 348 of file JvnObjectImpl.java.

References jvn.JvnObjectImpl.__containedObject, and jvn.JvnObjectImpl.__containedObjectLockState.

                                                                               {
                synchronized(this) {
                        if( __containedObjectLockState == JvnObjectState.STATE_WLOCKT ) {
//                              System.out.println("Invalidating writer for reader: current state is \"write lock taken\".");
                                try {
                                        // Wait while not ready.
                                        while( __containedObjectLockState == JvnObjectState.STATE_WLOCKT ) {
                                                this.wait();
                                        }
                                } catch (InterruptedException e) {
                                        throw new JvnException( "InterruptedException has occured while invalidating writer for reader!\n" + e);
                                }

                                __containedObjectLockState = JvnObjectState.STATE_RLOCKC;
                        } else if( __containedObjectLockState == JvnObjectState.STATE_WLOCKC ) {
//                              System.out.println("Invalidating writer for reader: current state is \"write lock cached\".");
                                __containedObjectLockState = JvnObjectState.STATE_RLOCKC;
                        } else {
                                // Don't throw this: we sometimes have some small sync issues
                                // for states (duplicate messages are sent), but it's ignorable
//                              throw new JvnException( "Tried to invalidate a writer but object state is not a writing state, it is: " + __containedObjectLockState );
                        }

//                      System.out.println("Writer invalidation OK: current state is \"read lock cached\".");
                        return __containedObject;
                }
        }

---

Member Data Documentation

final long jvn.JvnObjectImpl.serialVersionUID = -1348964285294975085L [static, private]

Automatically generated serial version ID

Definition at line 21 of file JvnObjectImpl.java.

Serializable jvn.JvnObjectImpl.__containedObject = null [protected]

Content of the object. private -> protected for Jvn2.

See also:

JvnObjectImpl.jvnGetObjectState()

Definition at line 29 of file JvnObjectImpl.java.

Referenced by jvn.JvnObjectImpl.jvnGetObjectState(), jvn.JvnObjectImpl.jvnInvalidateWriter(), jvn.JvnObjectImpl.jvnInvalidateWriterForReader(), jvn.JvnObjectImpl.jvnLockRead(), jvn.JvnObjectImpl.jvnLockWrite(), jvn.JvnObjectImpl.JvnObjectImpl(), irc.JvnSentence.JvnRead(), counter.JvnIntegerWrapper.JvnRead(), irc.JvnSentence.JvnWrite(), and counter.JvnIntegerWrapper.JvnWrite().

JvnObjectState jvn.JvnObjectImpl.__containedObjectLockState = null [package]

Lock state of the object.

Note that the JvnObjectImpl#jvnLockRead() and JvnObjectImpl#jvnLockWrite() methods synchronize using this member in order to have only one request at a time.

We need to do it this way (and not the inverse, say synchronize on this object for all methods accessing this members and synchronize on JvnObjectImpl to have one request at a time) otherwise we get some IllegalMonitorStateException and therefore need weird additional synchronize calls everywhere...

Definition at line 44 of file JvnObjectImpl.java.

Referenced by jvn.JvnObjectImpl.jvnGetObjectState(), jvn.JvnObjectImpl.jvnInvalidateReader(), jvn.JvnObjectImpl.jvnInvalidateWriter(), jvn.JvnObjectImpl.jvnInvalidateWriterForReader(), jvn.JvnObjectImpl.jvnLockRead(), jvn.JvnObjectImpl.jvnLockWrite(), jvn.JvnObjectImpl.JvnObjectImpl(), and jvn.JvnObjectImpl.jvnUnLock().

int jvn.JvnObjectImpl.numberOfReadLocks = -1 [private]

Number of read locks pending on the local server.

Definition at line 49 of file JvnObjectImpl.java.

Referenced by jvn.JvnObjectImpl.jvnLockRead(), jvn.JvnObjectImpl.JvnObjectImpl(), and jvn.JvnObjectImpl.jvnUnLock().

int jvn.JvnObjectImpl.jvnObjectId = -1 [private]

Object ID of the Javanaise object.

See also:

JvnObjectImpl.jvnGetObjectId()

JvnObjectImpl.jvnSetObjectId(int)

JvnCoordImpl.jvnGetObjectId()

Definition at line 58 of file JvnObjectImpl.java.

Referenced by jvn.JvnObjectImpl.jvnGetObjectId(), jvn.JvnObjectImpl.jvnLockRead(), jvn.JvnObjectImpl.jvnLockWrite(), and jvn.JvnObjectImpl.jvnSetObjectId().

---

The documentation for this class was generated from the following file:

• JvnObjectImpl.java

---